Adjuncts

Caution

These features are still under development.

Any asset in the platform can have a list of linked files, which can be externally hosted or hosted by the platform. For an image asset, a linked file might be OCR text derived from the image, or web annotations transcribing the image, or a spectral analysis, or in fact any kind of data you need to attach to the asset. For AV assets, an adjunct might be a WebVTT captions file.

Adjuncts are linked in the API from the asset to a Hydra collection:

{
  "@context": "https://dlcs.github.io/vocab/context/future.json",
  "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2",
  "@type": "vocab:Image",

  "adjuncts": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts"

}

This is a Hydra collection of files associated with the asset, and stored and served by the platform. A GET on that URI might return:

{
    "@context": "https://dlcs.github.io/vocab/context/future.json",
    "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts",
    "@type": "Collection",
    "totalItems": 2,
    "member": [
        {
            "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/b2921371x_0001.xml",
            "asset": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2",
            "@type": "Dataset",
            "publicId": "https://dlcs.example/adjuncts/2/5/b2921371x_0001.jp2/b2921371x_0001.xml",
            "label": { "en": [ "METS-ALTO text for b2921371x_0001.jp2" ] },
            "mediaType": "text/xml",
            "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
            "language": [ "en" ],
            "origin": "https://s3-eu-west-1.amazonaws.com/example-bucket/digitised/b2921371x/v1/data/objects/alto/b2921371x_0001.xml",
            "size": 240563,
            "iiifLink": "seeAlso",
            "motivation": null,
            "provides": null,
            "ingesting": false,
            "error": null,
            "created": "2025-09-22T16:45:29+00:00",
            "finished": "2025-09-22T16:45:32+00:00"
        },
        {
            "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/b2921371x_0001.anno.json",
            "asset": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2",
            "@type": "AnnotationPage",
            "publicId": "https://dlcs.example/adjuncts/2/5/b2921371x_0001.jp2/b2921371x_0001.anno.json",
            "label": { "en": [ "IIIF Annotations for b2921371x_0001.jp2" ] },
            "mediaType": "application/json",
            "language": [ "en" ],
            "origin": "https://s3-eu-west-1.amazonaws.com/example-bucket/digitised/b2921371x/v1/data/objects/annotations/b2921371x_0001.anno.json",
            "size": 390553,
            "iiifLink": "annotations",
            "motivation": null,
            "provides": null,
            "ingesting": false,
            "error": null,
            "created": "2025-09-22T16:49:29+00:00",
            "finished": "2025-09-22T16:49:32+00:00"
        }
    ]
}

There is no vocab:Adjunct type because an adjunct can be any kind of resource. Here the first adjunct has @type Dataset (from Dublin Core via IIIF) and the second is AnnotationPage. It is recommended to use types defined by IIIF, so that when your adjuncts are encountered in a IIIF Manifest the type property is from a known vocabulary. This isn’t mandatory, they can be anything — with one exception: an adjunct whose iiifLink is annotations must have @type AnnotationPage (see @type).

In the above example, both adjuncts were supplied via an origin in the same way that assets are supplied: the platform fetched each from its origin, using the same customer origin strategies if necessary, and now stores and serves it at its publicId. The first is a METS-ALTO file, linked from the asset’s canvas as seeAlso; the second is a IIIF Annotation Page (for example, line-level text annotations derived from that ALTO by your own process), which the platform links from the canvas’s annotations property.

Note

All adjuncts on this page are created by the API caller, either by supplying an origin for the platform to fetch, or an externalId for a resource hosted elsewhere. Platform pipelines that generate adjuncts (for example, deriving annotations from OCR) are a planned capability and are not yet available.

HTTP operations

/customers/{customer}/spaces/{space}/images/{imageId}/adjuncts

Method	Label	Expects	Returns	Status
GET	List the asset’s adjuncts	-	🔗 hydra:Collection (of adjuncts)	200 OK, 404 Not Found
POST	Add one or more adjuncts	an adjunct, or a hydra:Collection of adjuncts	🔗 hydra:Collection (of the adjuncts)	201 Created, 200 OK, 400 Bad Request, 409 Conflict

/customers/{customer}/spaces/{space}/images/{imageId}/adjuncts/{adjunctId}

Method	Label	Expects	Returns	Status
GET	Retrieve an adjunct	-	an adjunct	200 OK, 404 Not Found
PUT	Create or replace an adjunct	an adjunct	an adjunct	201 Created, 200 OK, 400 Bad Request
DELETE	Delete an adjunct	-	owl:Nothing	204 No Content, 404 Not Found

A POST returns 409 Conflict if any adjunct id in the request already exists on the asset; use PUT to replace an existing adjunct. A PUT returns 201 when it creates and 200 when it replaces. Deleting an adjunct removes it from the asset and, for adjuncts hosted by the platform, deletes the stored content. There is also a bulk delete across assets — see Deleting multiple adjuncts.

Creating and registering Adjuncts

An adjunct can either be external (hosted somewhere else), or hosted by the platform. If external, the platform has nothing to do with serving the adjunct and merely records the link between the asset and the external resource. This is still useful because that link can be expressed in generated IIIF. At registration time, you specify the externalId property, which will remain the public URL of the adjunct.

If it is to be hosted by the platform, you specify an origin when creating the adjunct, in the same way origin works for assets.

In both cases the publicId of the adjunct shows where end-users will load the adjunct from (and where IIIF resources should link to), but for adjuncts registered from an origin, the publicId will be a platform-managed URL.

Adjuncts can be created by a POST to the asset’s adjuncts property URL, or a PUT directly to the API @id under that URL.

Creating an adjunct that links to an external URL

POST https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts
{
    "id": "mets-external",
    "externalId": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "@type": "Dataset",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "size": 36032,
    "iiifLink": "seeAlso",
    "language": [ "en" ]
}

or by PUT (id is optional but if present, must match the PUT URL):

PUT https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-external
{
    "externalId": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "@type": "Dataset",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "size": 36032,
    "iiifLink": "seeAlso",
    "language": [ "en" ]
}

In both these cases the request will return HTTP 201 Created, and the created adjunct is available immediately and looks like this. (POSTing an id that already exists on the asset returns 409 Conflict; a PUT to an adjunct that already exists updates it and returns 200 OK.) Note the difference in response body: PUT returns the adjunct itself, but POST always returns a collection wrapping the created adjunct(s), even when you POSTed a single one:

{
    "@context": "http://www.w3.org/ns/hydra/context.jsonld",
    "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts",
    "@type": "Collection",
    "totalItems": 1,
    "pageSize": 1,
    "member": [
        { "... the created adjunct, as below ...": "" }
    ]
}

A GET of the adjunct’s own @id returns it unwrapped:

GET https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-external

returns:

{
    "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-external",
    "asset": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2",
    "publicId": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "@type": "Dataset",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "size": 36032,
    "iiifLink": "seeAlso",
    "motivation": null,
    "provides": null,
    "ingesting": false,
    "error": null,
    "created": "2025-09-22T16:49:29+00:00",
    "finished": "2025-09-22T16:49:29+00:00",
    "language": [ "en" ]
}

💻 Create an external adjunct Create an adjunct that links to an external URL, via POST and PUT

Creating an adjunct from an origin

In this case the content of the adjunct will be fetched from the origin and thereafter served by the platform on a managed URL. Note that we do not need to supply a size (if we do it will be ignored) as the platform will measure and store the actual size (in bytes).

POST https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts
{
    "id": "mets-from-origin.xml",
    "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "@type": "Dataset",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "iiifLink": "seeAlso",
    "language": [ "en" ]
}

or by PUT (id is optional but if present, must match the PUT URL):

PUT https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-from-origin.xml
{
    "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "@type": "Dataset",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "iiifLink": "seeAlso",
    "language": [ "en" ]
}

In both these cases the request will return HTTP 201 Created immediately (the adjunct information is available immediately; as above, a duplicate POST returns 409 Conflict and a PUT-update returns 200 OK, and a POST response wraps the adjunct in a collection), but the ingesting property will be true and will continue to have that status until the adjunct content has been fetched from the origin and stored, at which point the ingesting property will be false. The created adjunct would look like this:

GET https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-from-origin.xml

returns:

{
    "@id": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts/mets-from-origin.xml",
    "asset": "https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2",
    "@type": "Dataset",
    "publicId": "https://dlcs.example/adjuncts/2/5/b2921371x_0001.jp2/mets-from-origin.xml",
    "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
    "label": { "en": [ "METS-ALTO XML" ] },
    "size": 36032,
    "iiifLink": "seeAlso",
    "motivation": null,
    "provides": null,
    "ingesting": false,
    "error": null,
    "created": "2025-09-22T16:49:29+00:00",
    "finished": "2025-09-22T16:49:34+00:00",
    "language": [ "en" ],
    "batch": "https://api.dlcs.example/customers/2/adjunctQueue/batches/871143",
}

💻 Create an adjunct from an origin Create an adjunct by supplying an origin for the platform to fetch and store

Registering multiple adjuncts

An asset can have any number of adjuncts. They can be created/registered in separate HTTP operations as above, or in bulk by a POST to the asset’s adjunct endpoint. This POST to the asset’s adjuncts collection can take a single adjunct, an array of adjuncts, or a Hydra Collection with an array of adjuncts as member.

POST https://api.dlcs.example/customers/2/spaces/5/images/b2921371x_0001.jp2/adjuncts
[
    {
        "id": "mets-from-origin",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
        "@type": "Dataset",
        "mediaType": "text/xml",
        "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
        "label": { "en": [ "METS-ALTO XML" ] },
        "iiifLink": "seeAlso"
    },
    {
        "id": "annotations-from-origin",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.line.json",
        "@type": "AnnotationPage",
        "mediaType": "application/json",
        "label": { "en": [ "Line-level annotations" ] },
        "iiifLink": "annotations"
    }
]

The response status code describes the aggregate outcome of the request — per-member results are not itemised. A multi-adjunct POST returns 201 Created when every member was newly created, and 200 OK when any member updated an existing adjunct; a 201 from this endpoint therefore always means everything in the request is new. (This follows RFC 9110, which defines 201 as a request that resulted in “one or more new resources” being created.)

Caution

Adjuncts are not currently access-controlled. Adjuncts hosted by the platform are served openly at their publicId regardless of any roles on the parent asset, and no IIIF Auth services are emitted for them in generated manifests. Do not register content that must stay restricted as a hosted adjunct of a restricted asset. A roles property sent when creating an adjunct is ignored and not stored.

💻 Register multiple adjuncts in bulk POST an array of adjuncts in a single request

Deleting multiple adjuncts

Adjuncts can be deleted individually with a DELETE on the adjunct’s @id. To delete many adjuncts in one request, across any of your assets and spaces, POST a collection to /customers/{customer}/deleteAdjuncts. Each member names an asset by its full identifier (customer/space/asset-id) and lists the adjunct ids to delete from it:

POST /customers/2/deleteAdjuncts
{
    "@context": "http://www.w3.org/ns/hydra/context.jsonld",
    "@type": "Collection",
    "member": [
        { "id": "2/5/b2921371x_0001.jp2", "adjunct": [ "b2921371x_0001.xml", "b2921371x_0001.anno.json" ] },
        { "id": "2/5/b2921371x_0002.jp2", "adjunct": [ "b2921371x_0002.xml" ] }
    ]
}

The member list must not be empty, an adjunct id must not be repeated for the same asset, and the request is limited to 500 adjuncts (platform-configurable). Adjuncts in the list that do not exist are ignored; if none of them exist the request fails with 400 Bad Request.

/customers/{customer}/deleteAdjuncts

Method	Label	Expects	Returns	Status
POST	Delete the listed adjuncts	🔗 hydra:Collection	-	204 No Content, 400 Bad Request

💻 Delete multiple adjuncts Create two throwaway adjuncts, delete both with one POST to deleteAdjuncts, and show they are gone

Adjunct fields

@id

The API URL of the JSON resource. This is always of the form <asset-@id>/adjuncts/<adjunct-id>. It is not usually supplied by the API caller on a PUT or a POST. If it is supplied it must not conflict with any of the other fields that contribute to the URI.

id

The model id of the adjunct. Required on a POST when creating an adjunct, to provide a “filename” or last path element for the adjunct. The platform will not mint a value if one is not supplied (unlike assets). On a POST, it must not conflict with any of the asset’s other adjuncts. Optional on a PUT; if present, it must match the last element in the PUT URL path.

The id property, whether supplied explicitly in a POST or as the last path element in a PUT, appears in the public URL of the asset as served by the platform (see publicId).

asset

The API @id of the asset this adjunct belongs to, always of the form <base-url>/customers/<customer>/spaces/<space>/images/<asset-id>. It is emitted on every adjunct representation.

On a POST or PUT to an asset’s own adjuncts collection the asset is determined by the URL and any asset value in the body is ignored. When registering adjuncts through the adjunct queue, each member must carry asset, either as the fully qualified @id above or in the short form customer/space/asset-id; the referenced asset must belong to the requesting customer, and each asset/id pair in the request must be unique.

domain	range	readonly	writeonly
vocab:Adjunct	xsd:string	False	False

@type

For most platform types this is inferred from where the resource lives (what collection it’s in) but for adjuncts it must be specified. It has the same meaning as in the IIIF Presentation Specification (see type) and should use type values defined by that specification, like Dataset, Text or AnnotationPage. It will appear in any generated IIIF.

There is one constraint: when iiifLink is annotations, @type must be AnnotationPage, because the platform places the adjunct itself directly in the Canvas annotations list. Any other combination is rejected with 400 Bad Request. For the other iiifLink values the adjunct becomes the body or target of a link and @type is passed through unchanged, so any IIIF type is valid.

mediaType

This is the same as asset.mediaType — the internet content type (or MIME type) of the resource, the value that the platform will provide in the Content-Type header when it serves the adjunct’s binary content. If you are supplying the adjunct yourself, for the platform to store and serve, you must supply a mediaType.

Whenever the adjunct appears in a Manifest served by the platform, the value of this field is used as the format property.

profile

This is the same as the IIIF Presentation API profile property: ”… profile can further clarify the type and/or format of an external resource or service”. In the earlier example, the METS-ALTO file has:

{
    "mediaType": "text/xml",
    "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd"
}

profile is informing a client that this XML resource is specifically a v3 ALTO file.

If you are supplying the adjunct yourself, for the platform to store and serve, you should supply a profile, but it is not mandatory and sometimes not relevant or possible.

label

This is the same as the IIIF Presentation API label property, and is a JSON LD Language Map (see the IIIF Presentation API). It is recommended to always supply this: without a label, the seeAlso, rendering or annotations entry for the adjunct in any generated manifest has no label for viewers to display. For platform-generated adjuncts, a default label will be assigned if nothing is supplied.

language

The language of an adjunct’s content, if applicable. The value is a JSON array of ISO language codes (sub-codes are allowed). See iiifLink for an example of how this property is used and how it appears in generated IIIF.

origin

Works in the same way as asset.origin and uses the same origin strategies where applicable. An origin is not allowed when asking the platform to create the adjunct via a pipeline, but is required when you are supplying an adjunct for the platform to host: the platform will fetch the content from the origin and serve it from a managed URL.

error

A string message from any error(s) encountered the last time this adjunct was processed. If re-processed the value will be cleared.

externalId

Only valid when creating an adjunct. externalId is a fully-qualified URL external to the platform. The platform will not fetch or interrogate the URL in any way — unlike origin. The value of externalId will be expressed in IIIF as the id of the adjunct.

publicId

The URL from which the adjunct’s binary content is served. This is a read-only property and will be ignored if supplied on a POST or PUT. This will appear as the adjunct’s IIIF id in any platform-generated IIIF manifest. If the adjunct was created from an origin, publicId will be of the form <base-url>/adjuncts/<customer>/<space>/<asset-id>/<adjunct-id>, e.g., https://dlcs.example/adjuncts/2/5/b2921371x_0001.jp2/mets-from-origin.xml. If the adjunct was created or updated with externalId, the publicId is that value.

size

The size in bytes of the adjunct. For adjuncts created from an origin, size is absent from the representation until the platform has fetched and stored the content (while ingesting is true); it is then populated with the actual stored byte count whether or not you supplied a value. In rare cases where the platform cannot determine the size of content it serves from an optimised origin, size may remain absent. For adjuncts created with externalId you can supply this yourself. For external adjuncts it is still optional; if absent, it will be omitted from the IIIF representation. As IIIF it appears as the fileSize property, introduced in IIIF Presentation 4.0.

batch

The batch this adjunct was ingested in (most recently). This is a link to the adjunct batch object created when this adjunct was last ingested via a queue.

An adjunct created directly with a direct PUT will not have a batch link.

Batches may also be archived, and an adjunct may lose the reference to its ingest batch after a long period (greater than one year).

domain	range	readonly	writeonly
vocab:Adjunct	🔗 vocab:AdjunctBatch	True	False

The batch link on an adjunct points directly to the adjunct batch resource:

/customers/{customer}/adjunctQueue/batches/{batchId}

Method	Label	Expects	Returns	Status
GET	Retrieve the adjuncts’s batch	-	vocab:AdjunctBatch	200 OK, 404 Not Found

💻 Get adjunct batch Submit an adjunct via the queue and follow its batch link to retrieve the AdjunctBatch

iiifLink

This property is required. Valid values are seeAlso, rendering, annotations and inlineAnnotation. When generating IIIF the platform will list an asset’s adjuncts under the equivalent IIIF properties of a Canvas, or as an inline annotation (see example below). An adjunct with iiifLink annotations must have @type AnnotationPage (see @type).

For example, an asset with four adjuncts created like this:

POST https://api.dlcs.example/customers/2/spaces/5/images/b29820947_0014.jp2/adjuncts
[
    {
        "id": "mets-from-origin.xml",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.xml",
        "@type": "Dataset",
        "mediaType": "text/xml",
        "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
        "label": { "en": [ "METS-ALTO XML" ] },
        "iiifLink": "seeAlso",
        "language": [ "en-GB", "cy" ]
    },
    {
        "id": "annotations-from-origin.json",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.line.json",
        "@type": "AnnotationPage",
        "mediaType": "application/json",
        "label": { "en": [ "Line-level annotations" ] },
        "iiifLink": "annotations",
        "language": [ "en", "cy" ]
    },
    {
        "id": "rendering-from-origin.jpg",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.jpg",
        "@type": "Image",
        "mediaType": "image/jpeg",
        "label": { "en": [ "A JPEG of the asset" ] },
        "iiifLink": "rendering"
    },
    {
        "id": "text-from-origin.txt",
        "origin": "https://dlcsstage-public-test-objects.s3.eu-west-1.amazonaws.com/images-with-text/b29820947_0014.jp2.txt",
        "@type": "Text",
        "mediaType": "text/plain",
        "label": { "en": [ "Plain text of this page" ] },
        "language": [ "en", "cy" ],
        "iiifLink": "inlineAnnotation",
        "motivation": "supplementing",
        "provides": "transcript"
    }
]

… will produce an IIIF Canvas in a named query or single-asset manifest with three properties:

{
    // many fields of Canvas omitted for brevity
    "id": "https://dlcs.example/iiif-img/2/5/b29820947_0014.jp2/canvas/c/1",
    "type": "Canvas",
    "seeAlso": [
        {
            "id": "https://dlcs.example/adjuncts/2/5/b29820947_0014.jp2/mets-from-origin.xml",
            "type": "Dataset",
            "profile": "http://www.loc.gov/standards/alto/v3/alto.xsd",
            "label": { "en": [ "METS-ALTO XML" ] },
            "format": "text/xml",
            "language": [ "en-GB", "cy" ]
        }
    ],
    "annotations": [
        {
            // iiifLink is "annotations", direct link to adjunct
            "id": "https://dlcs.example/adjuncts/2/5/b29820947_0014.jp2/annotations-from-origin.json",
            "type": "AnnotationPage",
            "label": { "en": [ "Line-level annotations" ] }
        },
        {
            // iiifLink is "inlineAnnotation"
            "id": "https://dlcs.example/adjunct-annotations/2/5/b29820947_0014.jp2",
            "type": "AnnotationPage",
            "label": { "en": [ "Inline annotations" ] },
            "items": [
                {
                    "id": "https://dlcs.example/adjunct-annotations/2/5/b29820947_0014.jp2/text-from-origin.txt",
                    "type": "Annotation",
                    "motivation": "supplementing",
                    "body": {
                        // adjunct is expressed as body of annotation
                        "id": "https://dlcs.example/adjuncts/2/5/b29820947_0014.jp2/text-from-origin.txt",
                        "type": "Text",
                        "label": { "en": [ "Plain text of this page" ] },
                        "format": "text/plain",
                        "language": [ "en", "cy" ]
                    },
                    "target": "https://dlcs.example/iiif-img/2/5/b29820947_0014.jp2/canvas/c/1"
                }
                // If more than one adjunct with iiifLink: inlineAnnotations, they are added to this
                // single managed Annotation Page.
            ]
        }
    ],
    "rendering": [
        {
            "id": "https://dlcs.example/adjuncts/2/5/b29820947_0014.jp2/rendering-from-origin.jpg",
            "type": "Image",
            "label": { "en": [ "A JPEG of the asset" ] },
            "format": "image/jpeg"
        }
    ]
}

Note

Some adjunct properties are not yet expressed in the generated IIIF. provides and size (which will appear as the IIIF Presentation 4 fileSize property) are collected and returned by the API now, but emitting them waits until the platform implements Presentation 4 — planned, tracked in protagonist #1299. The same issue notes that an annotations page link currently carries only id, type and label.

The property inlineAnnotation is not a valid IIIF property, but instead tells the platform to express the adjunct as an inline annotation on a “synthetic” annotation page, under the IIIF property annotations. This means adjuncts can appear directly linked from the annotations property, where the adjunct is itself an Annotation Page, or indirectly linked, where the adjunct is the body of an Annotation in an intermediate Annotation Page managed by the platform for this adjunct. The above example shows both of these.

💻 Demonstrate all iiifLink values Create four adjuncts using each iiifLink value to control how they appear in generated IIIF

motivation

Only used when iiifLink is "inlineAnnotation". It appears as the motivation property of the annotation, as in the example above.

The value appears in the resulting IIIF as the annotation’s motivation, as supplied — a single value is emitted as a single string, not wrapped in an array. The values should be taken from the W3C Web Annotation specification, or from the additional IIIF motivations provided by the Presentation API (e.g., “supplementing”).

provides

Only used when iiifLink is "inlineAnnotation". It will appear as the provides property of the annotation, but is not yet expressed in the generated IIIF — the value is collected and returned by the adjuncts API now, and will be emitted when the platform implements IIIF Presentation 4 (protagonist #1299).

The value of provides can be a single string or a comma-separated list of strings. The values should be taken from the list defined in the IIIF Presentation specification (e.g., “audioDescription” or “subtitles”).

Adjunct creation field usage

The following table assumes that you are responsible for the binary content of the adjunct.

Field	POST external	PUT external	POST from origin	PUT from origin	appears in IIIF
@id	optional*	optional*	not allowed	optional*	no
id	required	optional*	not allowed	optional*	as last path element if not external
asset	ignored (from URL)	ignored (from URL)	ignored (from URL)	ignored (from URL)	no — required per member via the adjunct queue
@type	required	required	required	required	yes, as type
mediaType	required	required	required	required	yes, as format
profile	optional	optional	optional	optional	yes, as profile
label	recommended	recommended	recommended	recommended	yes
language	optional	optional	optional	optional	yes (but not on annotations page links)
origin	not allowed	not allowed	required	required	no
externalId	required	required	not allowed	not allowed	yes, as id of adjunct if external
publicId	ignored	ignored	ignored	ignored	The IIIF id
size	recommended	recommended	ignored	ignored	as IIIF P4 fileSize when Presentation 4 lands (#1299)
iiifLink	required	required	required	required	as linking property
motivation	nb**	nb**	nb**	nb**	as annotation property
provides	nb**	nb**	nb**	nb**	when Presentation 4 lands (#1299)

• * must match other fields
• ** Only used when iiifLink is "inlineAnnotation"