Digital Scholarship Guides

1. Create an Internet Archive account using an email and password. Note that the Internet Archive experienced cyberattacks in 2024 that allowed the hackers to steal user emails, so we suggest being cautious when creating accounts. We do not suggest adding your full name, personal information, etc. to your account.
2. Go to upload in the top right corner of the screen. Drag or select an image from your local device to upload.
3. Once the image has loaded, add metadata to your image. Certain fields are required: Description and Subject Tags.
4. Select No next to “Test Items”; this is required for this method to work.
5. Click the Upload button at the bottom of the screen. Wait for the image to load in a new tab.
6. Scroll down on the image page to the Identifier field. Copy the identifier.
7. Paste the identifier into the following URL scheme: https://iiif.archive.org/iiif/[identifier]/manifest.json.
8. Paste the URL into whatever viewer you wish.

1. Download images from your repository of choice. TIFs are best, JPEG 2000s are the next best and JPEGs are the next next best.
2. Check the file sizes. Export images that are over 100mb to smaller JPEGs, as close to lossless as possible. If you’re working on a Mac, you can do this in Preview by going to File > Export and selecting JPEG.
3. Log into a personal GitHub account.
4. Open the IIIF Workbench link. Allow access to your GitHub repositories.
5. Create a new project and upload all images to the workbench, one by one.
6. Wait 2-15 minutes for the images to process, generate tiles, upload to GitHub, and publish to the web. This may take a while, so try to have patience.
7. After the images load, copy the info.json URI below an image.
8. Open a manifest editor in a browser and add a canvas. Copy the URI into the canvas.
9. Manually add metadata for each image. I often copy the metadata from the repository catalog record, but you can determine your scheme and make your own fields.
10. Save the manifest to local machine. Then upload the manifest to the IIIF Workbench.
11. Test manifest URIs in a viewer.

If you want the manifests to be hosted by a personal GitHub account, you can stop here. However, if you would like them to be hosted by an organizational GitHub account, do the following:

1. Open the repository on GitHub and transfer ownership of the project repository. Alternatively, you can download all images and manifests files and reupload them to the organizational GitHub account one by one.
2. Do a search in your repository for the personal account username. Edit files to remove the username for the personal GitHub account and replace it with organizational GitHub username. Commit your changes.
3. Test manifest URIs in a viewer.

1. Create a folder/directory “iiif-workshop” on your local device.
2. Log into your organizational or personal GitHub account.
3. In the repository, create a manifests folder, an images folder, and update your README.md with appropriate information about the project. If you’d like to use GitHub Pages to create a viewable hub for manifests and images, copy the code from glenrobson’s iiif-workbench repository’s plugins directory and index.md file.
4. Download iiif-tiler.jar and place it in your iiif-workshop directory.
5. Download images from your repository of choice. TIFs are best, JPEG 2000s are the next best and JPEGs are the next next best.
6. Check the file sizes. Export images that are over 100mb to smaller JPEGs, as close to lossless as possible. If you’re working on a Mac, you can do this in Preview by going to File > Export and selecting JPEG.
7. Make sure your file names are distinct. Files must have different names or the tiler will concatenate them.
8. Place all images in a directory titled iiif-workshop on your local device.
9. Run a command for cd ~/iiif-workshop java -jar iiif-tiler.jar in the Terminal on your local device. If you don’t have Java installed for whatever reason, you’ll have to do that first.
10. Wait for a directory titled iiif to appear in the iiif-workshop directory. When you open the new iiif directory, you’ll find folders containing the tiles of each image and an info.json file.
11. Create a new directory in your GitHub repository’s images directory for each image. It’s easiest to name the directory, the image, and the manifest all the same thing so you don’t get confused.
12. For each image, upload the info.json file and all tile files into the appropriately named GitHub directory. You may have to do this in batches, since GitHub has a cap on uploads with file size and amount.
13. After all files have uploaded succesfully, copy URIs for each image from the info.json file. Add /info.json on the end.
14. Open a manifest editor in a browser and add a canvas. Copy the URI into the canvas.
15. Manually add metadata for each image. I often copy the metadata from the repository catalog record, but you can determine your scheme and make your own fields.
16. Save the manifest to your local machine.
17. Upload the manifests to the manifests directory of your GitHub repository.
18. Edit each manifest in the manifests directory to correct the @id so that it reads “https://[user].github.io/[repo]/manifests/[manifest name].json“.
19. Commit changes. Test new manifest URIs.

1. Install libvips to your local machine. Follow the libvips installation instructions.
2. Log into your organizational or personal GitHub.com account.
3. Create a new repository. In the repository, create a manifests folder and an images folder.
4. On your local machine, create a new folder to store all of your images.
5. Download images from your repository of choice. TIFFs are best, JPEG 2000s are the next best and JPEGs are third best.
6. Place all images in the folder you created in step 3.
7. Open the command line. Change directories to the directory that your image is in, e.g.: cd Downloads
8. Run a command: vips dzsave yourimagename –layout iiif mypyr.zip
9. Wait for a folder named mypyr.zip to appear on your computer. When you open the zip file, you’ll find folders containing the tiles of your image and an info.json file.
10. Create a new folder in your GitHub repository’s images folder for each image. Going forward, it’s easiest to name the image folder and the manifest the same thing so you don’t get confused.
11. For each image, upload the info.json file and all tile files into the appropriately named image folder in your GitHub repository. You may have to do this in batches, since GitHub has a cap on uploads with file size and amount.
12. After all files have uploaded successfully, open the info.json file for each image and update the @id field to: “https://YOUR-GITHUB-USERNAME.github.io/YOUR-REPO-NAME/images/YOUR-IMAGE-NAME/”
13. Open a manifest editor in a browser and add a canvas. Copy the @id above and add /info.json to the end. Paste this URI into the canvas.
14. Manually add metadata for each image. I often copy the metadata from the repository catalog record, but you can determine your scheme and make your own fields.
15. Save the manifest to your local machine.
16. Upload the manifests to the manifests directory of your GitHub repository.
17. Open each manifest file to correct the @id so that it reads: “https://YOUR-GITHUB-USERNAME.github.io/YOUR-REPO-NAME/manifests/YOUR-IMAGE-NAME/”
18. Commit changes. Wait for the changes to finish processing.
19. Test your new manifest URLs. Your new manifest URLs should be the same as the @id field you just edited in step 17.