Plan a pilot box
Menu

What is IIIF, and does a small museum or archive need it?

Reader question: What is IIIF, what would it give our online collection, and what does it take for a small institution to adopt it?

By Dastok Editorial TeamIssue: Published

IIIF, the International Image Interoperability Framework, is a set of free, open specifications for delivering images and describing digitized objects on the web, so that any compatible viewer can zoom deep into them, show their pages in order, display their transcriptions and embed them on other sites. A small museum or archive does not have to run IIIF itself to benefit: many collection systems include it, hosted services provide it, and a static setup can run on ordinary web hosting. IIIF is worth adopting when your images hold detail people need to zoom into, or when partners and researchers will reuse them. It can wait when your collection system already serves your users and nobody is asking for reuse.

This article explains IIIF through what visitors would see and what you would have to run, compares it with posting JPEGs or relying on your collection system’s own viewer, and sets out the routes open to a small organization. The version numbers and lists below were checked on iiif.io in November 2026.

What is IIIF? The short version

IIIF (pronounced “triple-eye-eff”) is a family of web specifications for images and digitized objects, written and maintained by a community of libraries, museums, archives and software makers. It does not store your collection or replace your catalog. It standardizes how images and their basic structure travel from a server to a viewer, so the server and the viewer can come from different people.

IIIF’s own plain-language guide, How IIIF Works, puts the problem simply: web browsers “understand how to display formats like .jpg and .mp4 at defined sizes, but cannot do much else.” For images, IIIF adds “deep zoom, comparison, structure (i.e., for an object such as a book, structure = page order) and annotation.”

Two core specifications do most of the work

  • The Image API defines how an image server delivers pixels: the whole image or a smaller size, a zoomed region, a rotated view or a gray version, each requested by changing parts of a web address.
  • The Presentation API describes an object for a viewer in a JSON file called a manifest. IIIF describes the manifest as the file that “bundles up all the different elements of an IIIF object (such as a single image, or a series of images) with basic metadata (like title, description, and rights information) and structural information (such as page order).”

As of November 2026, the current versions are Image API 3.0.0 and Presentation API 3.0.0. Presentation API 4.0.0 is a release candidate, so 3.0 is the version to ask for today.

Four more specifications you may meet later

Specification Current version What it does
Content Search API 2.0.0 Searches the text attached to one object, such as the OCR of a ledger, so a viewer can highlight hits
Content State API 1.0.0 Encodes a link to a particular object, page or region so it opens the same way in any viewer
Authorization Flow API 2.0.0 Guides a user through your existing login or access rules for restricted images
Change Discovery API 1.0.0 Announces new and changed objects so aggregators and portals can harvest them

IIIF’s guide for implementers recommends implementing the Image and Presentation APIs first and adding the others later, and notes that you can start “at a simpler level and then return to add more features.”

Who stands behind it

The specifications are published under a Creative Commons license by the IIIF Consortium, which was formed in 2015 by 11 institutions and lists 73 members as of November 2026. Membership is open and encouraged, but you do not need to join to use the specifications. The IIIF Museums Community Group names adopters such as the Art Institute of Chicago, the Frick Collection, Harvard Art Museums, the National Gallery of Art and the Victoria and Albert Museum. Those are large institutions; this article is about the routes that suit a much smaller one.

What IIIF gives your visitors

IIIF changes what a visitor can do with an image once they find it. They can zoom into fine detail without downloading a large file, turn the pages of a volume in order, compare items side by side, read transcriptions next to the page, share a link to one corner of one page, and see your images embedded on other sites while the pixels still come from you.

Deep zoom on large originals

A IIIF viewer requests only the tiles of the image that are on screen, at the size the screen needs. That matters most for maps, plans, large photographs and dense ledgers. For example, suppose a 30 by 40 inch map is captured at 400 ppi: the master is 12,000 by 16,000 pixels, or 192 million pixels, about 576 MB of uncompressed color data. A visitor reading one lot number needs a few small tiles, not the whole file. Our large-format scanning page covers capture of sheets that size.

Structure, comparison and annotation

A manifest records page order, so a ledger opens as a volume rather than as 216 separate pictures. Viewers built for manifests can show two objects side by side, from your collection or from another institution that publishes IIIF. The Presentation API also carries annotations, which it says “might be OCR, a manual transcription or a translation of handwritten text,” so text can sit on or beside the page it came from.

Reuse, citation and sharing

IIIF’s Why IIIF page sums up the reuse case as “publish once, reuse often”: “host a single copy and embed in other sites.” A teacher, a partner museum or a regional exhibit can show your item in their own pages while you keep control of the master and the credit line. The Content State API lets someone send a link that opens a particular page at a particular zoom.

Maps and places

For maps, plats and views of places, two approved extensions to the Presentation API add geography. The navPlace extension, in IIIF’s words, “defines a new property, navPlace, which is defined by earthbound geographic coordinates in the form of GeoJSON-LD,” so an item can be shown on a modern web map. The Georeference extension provides “a pattern for georeferencing IIIF Presentation 3 API Canvases,” which is what a viewer needs to lay a historic map over a current one. Neither is needed on day one, but both reward a collection of local maps and photographs of known places.

Credit and rights travel with the image

A manifest can carry a requiredStatement, text the specification says clients “must render,” such as a credit line or a copyright statement. Its rights property takes a license or rights statement URI from Creative Commons or RightsStatements.org, so the same standard statement travels with the image to every viewer that reads the manifest.

Example (fictional). Suppose the Aster County Historical Society publishes Box 3 through IIIF. The Wren Gulch Mercantile day book becomes one manifest of 216 canvases, its pages, covers, spine and label in order. A visitor searching inside it for “smelter” sees the hits highlighted on the page images, drawn from the ALTO text made during recognition. A volunteer shares a link that opens page 77 zoomed to the entry for February 9, 1894. The cabinet card of Ida and Marit Okerlund shows its front and its pencil-annotated back side by side. A school in the next county embeds Ida’s April 12, 1893 letter in a lesson about the flood, and the society’s credit line and its Copyright Not Evaluated statement appear with it. The whole box, outside IIIF, is followed stage by stage on our example collection page.

What IIIF does not do

IIIF is an access layer for images and their presentation. It is not a catalog, a search engine across your collection, a preservation system, an accessibility fix or a rights decision, and planning goes better when those limits are clear from the start.

  • It is not your catalog. The Presentation API says its purpose is presentation to a human, and that it “explicitly does not aim to provide metadata that would allow a search engine to index digital objects.” The metadata in a manifest is a set of label and value pairs for display. Your catalog records in Dublin Core, MARC or EAD stay where they are, and a manifest can link to them through its seeAlso property.
  • It does not search across the collection. The Content Search API works inside one object, and the specification says “searching for metadata or other descriptive properties is not in scope.” Finding the right item in the first place is the job of your collection search. Our article on semantic search for archives explains how collection-wide search and a IIIF viewer fit together.
  • It does not preserve anything. Tiles and access images are derivatives. The masters, checksums and copies still need a preservation plan of their own.
  • It does not make a viewer accessible. Keyboard use, screen reader support and text alternatives depend on the viewer and on what you publish with it.
  • It does not clear rights. It carries the statement you assign. Deciding which statement applies is still your work, and our rights review worksheet is one way to record it.

How IIIF works behind the page

Behind a IIIF viewer are three parts: an image service that delivers pixels at any size or region, a manifest that describes the object, and the viewer that reads both. You can run each part yourself, get it from a vendor or build it as static files.

You hold IIIF APIs People see Master images TIFF or JPEG 2000, kept and preserved Records and text catalog fields, rights, OCR or transcriptions Image service tiles and sizes, plus info.json Manifest (JSON) page order, labels, rights, links to text Viewer on your site zoom, pages, search inside the item Viewers elsewhere a partner, a teacher, a researcher's tool points to Level 0: tiles and sizes made in advance and served as plain files. Levels 1 and 2: an image server makes them on request from the master.
How the core IIIF parts fit together. Diagram by the Dastok Editorial Team from IIIF's How IIIF Works page, the Guide for IIIF implementers and the Image API 3.0 compliance levels, checked November 2026.

The image service and its addresses

The Image API asks for an image with a web address in a fixed pattern: server, identifier, region, size, rotation, quality and format. A request ending /full/max/0/default.jpg asks for the whole image at its largest available size. Change the region to a set of pixel coordinates and you get that crop; change the size and you get a thumbnail. A companion file, info.json, tells a viewer the image’s dimensions and which sizes and tiles are available.

Three compliance levels

The Image API’s compliance document defines levels 0, 1 and 2. Level 0 is “the minimum set of parameters and features” and level 1 is “the recommended set.” At level 0, a service only has to deliver the sizes and tiles it lists in advance. The implementers’ guide explains the practical difference: the Image API “can be implemented with only a standard web server (e.g. Apache or Nginx) or with a purpose built application called an image server.” A web server alone gives level 0, and “through creating lots of static image sizes and tiles a level 0 implementation is simple and can still power deep zoom viewers.” An image server gives level 1 or 2, and the guide advises that vendors “should aim for a compliance level of at least level 1.”

A tiled pyramid takes extra storage, though less than people expect. Each level down holds a quarter of the pixels of the one above it, so a full pyramid adds about a third to the pixel count of the largest image (1 + 1/4 + 1/16 and so on, which approaches 4/3). Compression and tile format decide the actual bytes; the storage calculator helps with the masters themselves.

Manifests and viewers

Manifests “can either be statically or dynamically created,” the guide says, and the data in them usually comes from more than one system. It is frank about the cost: “It often takes custom development to integrate data from different systems.”

Viewers come in two kinds. Image viewers such as OpenSeadragon and Leaflet-IIIF need only the Image API and give deep zoom on one image, but they “cannot display metadata.” Manifest viewers such as Mirador and the Universal Viewer read the Presentation API and show metadata, page order and, in Mirador’s case, annotations. Whichever you use on your own site, the guide recommends publishing manifests, because they let users choose their own viewer.

What a manifest looks like

A manifest is a short, readable text file. The one below follows the pattern of the IIIF Cookbook’s recipe for an image with an image service, trimmed to the first of four images.

Example (fictional). A manifest for the first page of Ida Okerlund’s April 12, 1893 letter. The address example.org stands in for the society’s web host; the other three canvases, for the second page and the envelope’s front and back, repeat the same pattern.

{
  "@context": "http://iiif.io/api/presentation/3/context.json",
  "id": "https://example.org/iiif/ACHS-3-012/manifest.json",
  "type": "Manifest",
  "label": { "en": [ "Ida Okerlund to her sister Marit, April 12, 1893" ] },
  "requiredStatement": {
    "label": { "en": [ "Credit" ] },
    "value": { "en": [ "Aster County Historical Society, Box 3" ] }
  },
  "rights": "http://rightsstatements.org/vocab/CNE/1.0/",
  "items": [ {
    "id": "https://example.org/iiif/ACHS-3-012/canvas/p1",
    "type": "Canvas", "height": 3000, "width": 2400,
    "items": [ {
      "id": "https://example.org/iiif/ACHS-3-012/page/p1",
      "type": "AnnotationPage",
      "items": [ {
        "id": "https://example.org/iiif/ACHS-3-012/annotation/p1",
        "type": "Annotation", "motivation": "painting",
        "body": {
          "id": "https://example.org/iiif/ACHS-3-012_0001/full/max/0/default.jpg",
          "type": "Image", "format": "image/jpeg",
          "service": [ {
            "id": "https://example.org/iiif/ACHS-3-012_0001",
            "type": "ImageService3", "profile": "level0"
          } ]
        },
        "target": "https://example.org/iiif/ACHS-3-012/canvas/p1"
      } ]
    } ]
  } ]
}

Read from the top, it says: this is a manifest; here is its title; show this credit line; this is its rights statement; it has one canvas of 2,400 by 3,000 pixels, painted with an image whose tiles come from a level 0 image service at this address. Everything a viewer needs to show the page in order, with credit, is there. Everything a cataloger needs to describe the letter stays in the catalog record.

Two technical requirements people miss

Images and manifests need to be served over HTTPS, and the server needs to allow cross-origin requests (CORS) so that viewers on other sites can load them. The guide names both: “your image server will need to support cross-origin resource sharing (CORS),” and images and manifests “should also be delivered with HTTPS.” A static setup on a host that cannot add a CORS header will work on your own site but not on anyone else’s.

IIIF compared with posting JPEGs or a built-in viewer

Most small institutions start with one of two arrangements: JPEG images on web pages, or the viewer built into their collection system. IIIF adds deep zoom on large images, portable structure and reuse elsewhere. It also adds work, unless your system already provides it.

Question JPEGs on web pages Collection system’s own viewer (not IIIF) IIIF
Can visitors zoom into fine detail on a large map or ledger? Only as far as the JPEG’s size allows Depends on the system Yes, tile by tile from a large master
Do multi-page items open in page order? Only if you build the page Depends on the system Yes, from the manifest
Can other sites show your images without copying them? They copy the file Depends on the system Yes, with your credit line and rights statement
Can visitors compare items from different institutions side by side? No Depends on the system Yes, in a manifest viewer
Can text be searched and highlighted inside a volume? No Depends on the system Yes, with the Content Search API and word positions
What happens when you change systems? Links break unless kept Viewer and links often change Manifests and image addresses can be kept stable
Effort for a small institution Lowest Low, already paid for Low if built in; moderate if hosted; moderate to high if self-run

There is also a middle path. The IIIF Cookbook’s simplest manifest wraps “one image on the web and a label” in a manifest without any image service. It gives you portable structure and reuse in IIIF viewers, but, as the recipe says, it “is not for large images or deep zoom functionality.” For photographs and letters whose access copies are already large enough to read, that can be a sensible start.

Routes to IIIF for a small institution

A small institution can adopt IIIF in three practical ways: use a collection system that already supports it, pay for a hosted service, or publish static IIIF files on ordinary web hosting. A fourth, running your own image server, suits organizations with IT staff. The right route depends on the system you already use and the skills you have, not on the size of the collection.

Route 1: a collection system with IIIF built in

Start with the system you already have, or the one you are about to choose. The implementers’ guide advises: “Consider reaching out to the vendors of your current systems. They may already have a IIIF implementation.” IIIF keeps a list of collection, asset management and repository software that supports IIIF, which includes CONTENTdm, Omeka, CollectiveAccess, eHive and Islandora among many others. Check the vendor’s own documentation for what each supports, because the list does not record versions or features.

Two examples from vendors’ own pages:

  • CONTENTdm. OCLC’s product page lists IIIF among the standards it supports and says the service is “fully hosted, so OCLC manages infrastructure.”
  • Omeka S. The Omeka team publishes a IIIF Presentation module described as “an Omeka S module that implements the IIIF Presentation API.” Third-party modules add an image server and viewers; the IIIF Server module, by Daniel Berthereau, can work with external image servers “like Cantaloupe or IIP Image.”

This route asks the least of your staff. Its limits are the system’s limits: which API versions it serves, whether manifests are public at stable addresses, and whether you can take them with you if you leave.

Route 2: a hosted IIIF service

Hosted services store your access images and serve them through the Image API, and some generate manifests. IIIF’s vendor page lists several and says they “all provide support for the IIIF Image API, and some provide additional features like IIIF manifest generation and search.” This route suits an institution whose collection system has no IIIF support but whose website can embed a viewer. Before signing, ask how you would export images and manifests, and whether image addresses would change if you moved.

Route 3: static IIIF on ordinary web hosting

A level 0 service needs no image server. You generate the tiles and info.json files once, write a manifest for each object, upload everything to a web host that serves HTTPS and allows CORS, and embed a viewer. The free image library libvips, for example, has a pyramid builder whose layout options include iiif and iiif3. Manifests can be written from a spreadsheet of your records with a small script; the IIIF Cookbook’s code samples use a Python library, iiif-prezi3.

This route costs little to host and has few moving parts once built. It needs someone comfortable with a command line and a script, and it has to be rerun when images or records change. It also stops at level 0, so viewers can only ask for the sizes and tiles you made in advance.

Route 4: your own image server

An image server makes tiles and sizes on request from the masters, at level 1 or 2. The implementers’ guide suggests that newcomers “begin with Cantaloupe which is easy to get running.” Cantaloupe’s own site describes it as “an open-source dynamic image server for on-demand generation of derivatives of high-resolution source images.” This route gives the most flexibility and asks the most of you: a server to patch, monitor and back up, plus manifests generated from your records.

Route What you run Skills needed What you get Watch for
Built into your collection system Nothing extra Configuration Image and Presentation APIs at the vendor’s level Versions supported; public manifests; export
Hosted IIIF service A subscription Uploading, embedding a viewer Image API; sometimes manifests and search Exit terms; stable addresses
Static files on web hosting A web host with HTTPS and CORS Command line, simple scripts Level 0 deep zoom; manifests you write Rebuilds after changes; level 0 limits
Your own image server A server and its upkeep Systems administration Level 1 or 2; full control Maintenance, security, backups

Costs to plan for on any route

The specifications are free to use; the work around them is not. Whichever route you choose, budget for these, in staff hours if not in money:

  • Preparing images: access derivatives or tiles made from the masters, and storage for them alongside the masters.
  • Writing manifests: a one-time mapping from your records, then a repeatable way to regenerate manifests when records change.
  • Embedding and testing a viewer: on your own pages, on phones, with a keyboard and with a screen reader.
  • Keeping addresses stable: a plan for redirects if you move hosts or systems, so links others have made keep working.
  • Someone who owns it: a named person who knows how it fits together, and notes that would let a successor take over.

On the built-in route most of these sit with the vendor. On the static and self-run routes they sit with you, and the last item matters most.

What adoption takes, step by step

Whatever the route, IIIF adoption is mostly preparation you would want anyway: good access images from sound masters, identifiers that will not change, records that can feed a manifest, and a decision about rights. The IIIF-specific part is smaller than it looks.

  1. Images. Make access derivatives from the masters at a size that shows the detail people need. For deep zoom, the source should be the full-resolution master or a high-quality derivative; IIIF’s guide notes that most people use JPEG 2000 or TIFF files.
  2. Identifiers and addresses. Choose an identifier for each image and object that will survive a change of system, and plan web addresses around it. IIIF’s Why IIIF page describes the aim as “URIs that persist through image server migrations.”
  3. Manifests from your records. Map each record’s title to the manifest label, a short description to summary, selected fields to metadata, your credit line to requiredStatement, and the rights statement URI to rights. Link the full catalog record through seeAlso.
  4. Structure. For volumes, record page order, and use ranges for sections such as months in a ledger. For letters, include envelopes and backs as canvases.
  5. Text. If you have OCR or transcriptions with word positions, such as ALTO XML, plan for the Content Search API so viewers can highlight hits inside an item.
  6. Viewer. Choose a viewer for your site, embed it, and test it on phones, with a keyboard and with a screen reader.
  7. Validation. IIIF publishes validators for the Image and Presentation APIs. The Presentation API validator checks a manifest by its address and reports errors and warnings.
  8. Upkeep. Write down how images and manifests are rebuilt when records change, and who does it.

In a small institution these steps usually fall to two or three people: whoever looks after the website or the vendor relationship, a cataloger or registrar who decides what the manifest says, and a director who signs off on rights and credit lines. None of them needs to become a developer, but one of them should be able to read a manifest and spot a missing page.

IIIF also publishes its online workshop materials, written for a five-day course that can be followed independently, with a video and exercises for each lesson. That is a reasonable first week for a staff member or volunteer taking this on.

Example (fictional). The Aster County Historical Society has a collections database with no IIIF support and a website on shared hosting. It chooses the static route for Box 3. A volunteer generates level 0 tiles for the 410 access images, and a short script reads the society’s CSV export to write 69 manifests, one per item, plus a collection manifest for the box. Each manifest takes its label from the record title, puts the date, names and places in metadata, carries the credit line “Aster County Historical Society, Box 3” in requiredStatement, and sets rights to the RightsStatements.org URI for Copyright Not Evaluated, matching the society’s rights review. The day book manifest groups its pages into monthly ranges. The host is asked to add a CORS header before anything is announced. Content Search waits for a second phase; for now, collection search runs on the society’s database and links each record to its viewer page.

When IIIF is worth it, and when to wait

IIIF pays off when people need to see fine detail, when items have many pages, or when others will reuse your images. It can wait when your current system already serves your users, when your images are small and few, or when your records and rights are not ready to publish.

Signal Points toward IIIF now Points toward waiting
Originals Maps, plans, large photographs, ledgers, illuminated or dense pages Snapshots, postcards, single-sheet letters readable at screen size
Collection system Already supports IIIF, or you are choosing a new one Meets your users’ needs and has no IIIF path; a migration is coming
Reuse Partners, teachers, researchers or an aggregator want to show your items Nobody outside your site uses the images
Text You have OCR or transcriptions with word positions No text yet, or text not reviewed
Staff Someone can maintain a host, a script or a vendor relationship No one can own it after launch
Records and rights Records clean enough to publish; rights statements assigned Description and rights review still to do

If the signals are mixed, start with one series that has real detail to show: a drawer of town plats, a ledger people consult often, a set of large-format photographs. Publish it through whichever route is closest to hand, watch how visitors and partners use it, and decide on the rest of the collection from that evidence rather than from the specification.

Waiting is not the same as doing nothing. Two choices keep the door open at little cost. First, keep full-resolution masters and stable identifiers, so tiles can be built later. Second, when you choose any new collection system or hosted platform, ask whether it serves Image API 3.0 and Presentation API 3.0 and whether you can export manifests. The museum object imaging and collection search pages describe how we prepare images and publishing for either path, and our page for museums covers the wider picture for smaller museums.

Accessibility and rights: two checks before you publish

Publishing through IIIF does not change your accessibility or rights obligations, but it changes where you check them. Test the viewer, not only your own pages, and settle the rights statement before it travels with your images to other sites.

Accessibility

If you are a state or local government body, such as a county records office or a public library, the Justice Department’s ADA Title II rule applies to your web content. The rule in 28 CFR 35.200 requires content an entity provides “directly or through contractual, licensing, or other arrangements” to meet WCAG 2.1 Level A and AA. That wording reaches a hosted viewer or platform as well as your own pages. An interim final rule published April 20, 2026 set compliance dates of April 26, 2027 for entities with a population of 50,000 or more, and April 26, 2028 for smaller entities and special districts, as checked in November 2026. Our article on ADA Title II and digitized collections covers the rule and its archived content exception in detail. None of this is legal advice.

For any institution, public or private, check that the viewer can be used with a keyboard alone, that controls have text labels a screen reader can announce, and that text versions of the pages, such as transcriptions or OCR, are reachable outside the image. The Presentation API’s rendering property can point to an alternative such as a PDF or a text file, which some readers will prefer.

Rights

The rights property in a manifest must hold a URI from Creative Commons or RightsStatements.org. RightsStatements.org provides “12 standardized rights statements for online cultural heritage,” including Copyright Not Evaluated for items whose status you have not yet researched. Because IIIF makes reuse easy, assign the statement before publishing, not after. For images that cannot be public, the Authorization Flow API supports access rules, and some image servers can serve degraded or watermarked versions; Cantaloupe, for example, lists “tiered access to dynamically degraded images.”

Questions to ask any platform or vendor about IIIF

Before you buy, renew or build, ask these questions in writing. The answers tell you whether IIIF will give you the benefits above or only the name.

  1. Which Image API version and compliance level do you serve? Is it 3.0, and at least level 1?
  2. Do you publish a Presentation API 3.0 manifest for every object, at a public, stable address?
  3. Are images and manifests served over HTTPS with CORS enabled, so other sites can load them?
  4. Which viewer do you provide, and has it been tested for keyboard and screen reader use?
  5. Can you map our credit line to requiredStatement and our rights statements to rights?
  6. Do you support the Content Search API for OCR or transcriptions, and which text formats can you ingest?
  7. How are restricted images handled: Authorization Flow, lower-resolution versions, or not published?
  8. If we leave, can we export images, manifests and records, and will the addresses keep working or redirect?
  9. Will you keep up with Presentation API 4.0 when it becomes stable?

If you would like help preparing images, text and records so that any of the four routes is open to you, our collection search service covers IIIF publishing and handover to your own system, and you can talk to us about a first box. Whichever route you take, start with one collection that has real detail to show, and let visitors’ use of it guide the next step.

Working through this with a real collection?

If this article describes a decision you are facing, tell us about the collection. A pilot box answers most questions with your own material.

Plan a pilot box

Studio and contacts

24 South Weber Street, Suite 225
Colorado Springs, CO 80903
(719) 244-8450sales@dastok.com