Annotations are typically used to convey information about a resource or associations between resources. Simple examples include a comment or tag on a single web page or image, or a blog post about a news article.
The Web Annotation Protocol describes the transport mechanisms for creating and managing annotations in a method that is consistent with the Web Architecture and REST best practices.
Status of This Document
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is a work in progress. No section should be considered final, and the absence of any content does not imply that such content is out of scope, or may not appear in the future. If you feel something should be covered, please tell us!
This document was published by the Web Annotation Working Group as a Candidate Recommendation. This document is intended to become a W3C Recommendation. If you wish to make comments regarding this document, please send them to
public-annotation@w3.org (subscribe,
archives).
W3C publishes a Candidate Recommendation to indicate that the document is believed to be stable and to encourage implementation by the developer community. This Candidate Recommendation is expected to advance to Proposed Recommendation no earlier than 30 September 2016. All comments are welcome.
Publication as a Candidate Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
Interoperability between systems has two basic aspects: the syntax and semantics of the data that is moved between the systems, and the transport mechanism for that movement. The HTTP protocol and the Web architecture provides us with a great starting point for a standardized transport layer, and can be used to move content between systems easily and effectively. Building upon these foundations allows us to make use of existing technology and patterns to ensure consistency and ease of development.
The Web Annotation Protocol describes a transport mechanism for creating, managing, and retrieving Annotations. Annotations in this specification are assumed to follow the requirements of the Web Annotation Data Model [annotation-model] and Web Annotation Vocabulary [annotation-vocab]. This specification builds upon REST principles and the Linked Data Platform [ldp] recommendation, and familiarity with it is recommended.
1.1 Aims of the Protocol
The primary aim of the Web Annotation Protocol is to provide a standard set of interactions that allow annotation clients and servers to interoperate seamlessly. By being able to discover annotation protocol end-points and how to interact with them, clients can be configured either automatically or by the user to store annotations in any compatible remote system, rather than being locked in to a single client and server pair.
1.2 Summary
For those familiar with the Web Annotation model, LDP, and REST, much of the Annotation Protocol will be very obvious. The following aspects are the most important new requirements.
The media type to use for Annotations is: application/ld+json;profile="http://www.w3.org/ns/anno.jsonld"
Annotation Containers are constrained by the set of constraints described in this specification, and thus the ldp:constrainedBy URL is http://www.w3.org/TR/annotation-protocol/
The link header can refer from any resource to an Annotation Container using a rel type of: http://www.w3.org/ns/oa#annotationService
The response from a Container after creating an Annotation SHOULD include a representation of the Annotation, after any changes have been made to it, in the JSON-LD serialization.
Annotation Containers SHOULD only contain Annotations, and not other resources.
Activity Streams Collection [activitystreams-core] model is used for paging, as in-page ordering is an important requirement.
1.3 Conformance
As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.
The key words MAY, MUST, RECOMMENDED, SHOULD, and SHOULD NOT are to be interpreted as described in [RFC2119].
1.4 Terminology
IRI
An IRI, or Internationalized Resource Identifier, is an extension to the URI specification to allow characters from Unicode, whereas URIs must be made up of a subset of ASCII characters. There is a mapping algorithm for translating between IRIs and the equivalent encoded URI form. IRIs are defined by [rfc3987].
Resource
An item of interest that MAY be identified by an IRI.
Web Server
A program that accepts connections in order to service HTTP requests by sending HTTP responses.
Annotation
A web resource that follows the Web Annotation Data Model [annotation-model].
Annotation Server
A Web Server that also makes available and allows the management of Annotations via the protocol described in this document.
Annotation Client
A program that establishes connections to Annotation Servers for the purpose of retrieving and managing Annotations via the protocol described in this document.
Annotation Container
An LDP Container [ldp] used to manage Annotations.
2. Web Annotation Protocol Principles
The Web Annotation Protocol is defined using the following basic principles:
The protocol is developed within the framework laid out by the Web Architecture.
Interactions will follow the REST best practice guidelines when there is a resource being acted upon.
Interactions are designed to take place over HTTP.
Existing specifications and systems will be re-used whenever possible, constrained further when necessary, with invention of new specifications only as a last resort.
Simplicity and ease of implementation are important design criteria, but ultimately subjective and less important than the above principles.
3. Annotation Retrieval
The Annotation Server MUST support the following HTTP methods on the Annotation's IRI:
GET (retrieve the description of the Annotation),
HEAD (retrieve the headers of the Annotation without an entity-body),
Servers SHOULD use HTTPS rather than HTTP for all interactions, including retrieval of Annotations.
Servers MUST support the JSON-LD representation using the Web Annotation profile. These responses MUST have a Content-Type header with the application/ld+json media type, and it SHOULD have the Web Annotation profile IRI of http://www.w3.org/ns/anno.jsonld in the profile parameter.
Servers SHOULD support a Turtle representation, and MAY support other formats. If more than one representation of the Annotation is available, then the server SHOULD support content negotiation. Content negotiation for different serializations is performed by including the desired media type in the HTTP Accept header of the request, however clients cannot assume that the server will honor their preferences [rfc7231].
Servers MAY support different JSON-LD profiles. Content negotiation for different JSON-LD profiles is performed by adding a profile parameter to the JSON-LD media type in a space separated, quoted list as part of the Accept header.
Servers SHOULD use the 200 HTTP status code when no errors occurred while processing the request to retrieve an Annotation, and MAY use 3XX HTTP status codes to redirect to a new location.
The response from the Annotation Server MUST have a Link header entry
where the target IRI is http://www.w3.org/ns/ldp#Resource and the rel parameter value is type. The Annotation type of http://www.w3.org/ns/oa#AnnotationMAY also be added with the same rel type.
The response MUST have an ETag header
with an entity reference value that implements the notion of entity tags from HTTP [rfc7232].
The response MUST have an Allow header
that lists the HTTP methods available for the Annotation [rfc7231].
If the server supports content negotiation by format or JSON-LD profile, the response MUST have a Vary header with Accept in the value. [rfc7231]
HTTP/1.1 200 OK
Content-Type: application/ld+json; profile="http://www.w3.org/ns/anno.jsonld"
Link: <http://www.w3.org/ns/ldp#Resource>; rel="type"
ETag: "_87e52ce126126"
Allow: PUT,GET,OPTIONS,HEAD,DELETE,PATCH
Vary: Accept
Content-Length: 287
{
"@context": "http://www.w3.org/ns/anno.jsonld",
"id": "http://example.org/annotations/anno1",
"type": "Annotation",
"created": "2015-01-31T12:03:45Z",
"body": {
"type": "TextualBody",
"value": "I like this page!"
},
"target": "http://www.example.com/index.html"
}
4. Annotation Containers
If the Annotation Server supports the management of Annotations, including one or more of creating, updating, and deleting them, then the following section's requirements apply. The Annotation Protocol is a use of the Linked Data Platform [ldp] specification, with some additional constraints derived from the Web Annotation Data Model [annotation-model].
An Annotation Server MUST provide one or more Containers within which Annotations can be managed: an Annotation Container. An Annotation Container is at the same time both a Container [ldp] (a service for managing Annotations) and a Collection [activitystreams-core] (an ordered list of Annotations). It can have descriptive and technical information associated with it to allow clients to present it to a user in order to allow her to decide if it should be used or not.
Annotation Containers SHOULD implement the LDP Basic Container specification, but MAY instead implement another type of Container, such as a Direct or Indirect Container, to fulfill business needs. Annotation Containers MAY have any IRI, but MUST end in a "/" character. The Annotations MUST be assigned IRIs with an additional path component below the Container's IRI.
Implementations SHOULD use HTTPS rather than HTTP for all interactions with Annotation Containers.
The creation, management, and structure of Annotation Containers are beyond the scope of this specification. Please see the Linked Data Platform specification [ldp] for additional information.
4.1 Container Retrieval
The Annotation Server MUST support the following HTTP methods on the Annotation Container's IRI:
GET (retrieve the description of the Container and the list of its contents, described below),
HEAD (retrieve the headers of the Container without an entity-body),
When an HTTP GET request is issued against the Annotation Container, the server MUST return a description of the container. That description MUST be available in JSON-LD, SHOULD be available in Turtle, and MAY be available in other formats. The JSON-LD serialization of the Container's description SHOULD use both the LDP context (http://www.w3c.org/ns/ldp.jsonld), and the Web Annotation's profile and context [annotation-model], unless the request would determine otherwise.
Servers SHOULD use the 200 HTTP status code if the request is successfully completed without errors and does not require redirection based on the client's preferences. If redirection is required, then the server SHOULD use a 3XX HTTP status code instead.
Clients that have a preference for JSON-LD SHOULD explicitly request it using an Accept header on the request. If the Accept header is absent from the request, then Annotation Servers MUST respond with the JSON-LD representation of the Annotation Container.
All supported methods for interacting with the Annotation Container SHOULD be advertised in the Allow header of the GET, HEAD and OPTIONS responses from the container's IRI
. The Allow header MAY also be included on any other responses.
Annotation Containers MUST return a Link header [rfc5988] on all responses with the following components:
It MUST advertise its type by including a link where the rel parameter value is type and the target IRI is the appropriate Container Type, such as http://www.w3.org/ns/ldp#BasicContainer for Basic Containers.
It MUST advertise that it imposes Annotation protocol specific constraints by including a link where the target IRI is http://www.w3.org/TR/annotation-protocol/, and the rel parameter value is the IRI http://www.w3.org/ns/ldp#constrainedBy.
All HTTP responses from Annotation Containers MUST include an ETag header that implements the notion of entity tags from HTTP [rfc7230].
If the server supports content negotiation by format or JSON-LD profile, the response from the Annotation Container MUST have a Vary header that includes Accept in the value.
Responses from Annotation Containers that support the use of the POST method to create Annotations SHOULD include an Accept-Post header on responses to GET, HEAD and OPTIONS requests. The value is a comma separated list of media-types that are acceptable for the client to send via POST [ldp].
Example 3: Example Annotation Container Headers
Link: <http://www.w3.org/ns/ldp#BasicContainer>; rel="type"
Link: <http://www.w3.org/TR/annotation-protocol/>; rel="http://www.w3.org/ns/ldp#constrainedBy"
ETag: "0f6b5cd8dc1f754a1738a53b1da34f6b"
Vary: Accept
Allow: POST, GET, OPTIONS, HEAD
Accept-Post: application/ld+json; profile="http://www.w3.org/ns/anno.jsonld", text/turtle
4.1.1 Client Preferences
There are three possibilities for the request that will govern the server's response:
If the client prefers to only receive the Container description and no annotations, then it MUST include the Prefer request header set to the value return=representation;include="http://www.w3.org/ns/ldp#PreferMinimalContainer".
If the client prefers to receive the list of annotations only as IRIs, then it MUST include the Prefer request header set to the value return=representation;include="http://www.w3.org/ns/oa#PreferContainedIRIs".
If the client prefers to receive the complete annotation description, then it MUST include the Prefer request header set to the value return=representation;include="http://www.w3.org/ns/oa#PreferContainedDescriptions".
If no preference is given by the client, the server SHOULD return the full annotation descriptions. The server MAY ignore the client's preference.
4.1.2 Responses without Annotations
The Client may request the description of the Annotation Container without any included Annotations.
The response SHOULD include links to the first and last AnnotationPages in the Collection, and without either the ldp:contains predicate or the first page of annotations embedded.
If the client requests a response that would include the Annotations, either by IRI or embedded in the response, then the server MUST use the paged collection model. Each page, described below, will contain an ordered list with a subset of the managed annotations, such that if every page is traversed, a client can reconstruct the complete, ordered contents of the container. The number of IRIs or Annotation descriptions included on each page is at the server's discretion, and may be inconsistent between pages. The feature or features by which the annotations are sorted are not explicit in the response.
The Collection SHOULD include the total property with the total number of annotations in the container. It MUST also have a link to the first page of its contents using first, and SHOULD have a link to the last page of its contents using last.
The IRI of the Collection in the response should differentiate between whether the pages contain just the IRIs, or the full descriptions of the Annotations. It is RECOMMENDED that this be done with a query parameter. The server MAY redirect the client to this IRI and deliver the response there, otherwise it MUST include a Content-Location header with the IRI as its value. The server SHOULD include Prefer in the Vary response header to assist with caching.
This request would generate a very similar response to the one above, just with some way to distinguish that the pages should embed the Annotations rather than just their IRIs.
Page Response
Individual pages are instances of CollectionPage. The page contains the Annotations, either via their IRIs or full descriptions, in the items property.
Each page MUST have a link to the container that it is part of, using the partOf property. If it is not the first page, it MUST have a link to the previous page in the sequence, using the prev property. If it is not the last page, it MUST have a link to the next page in the sequence, using the next property. The response MAY include properties of the Collection in the response, including the total number of items or first and last page links.
The client SHOULD NOT send the Prefer header when requesting the page, as it has already been taken into account when requesting the Container.
This specification does not require any particular functionality when a client makes requests other than GET, HEAD or OPTIONS to a page.
As the CollectionPage is not a Container, it does not have the requirement to include a Link header with a type. That the URLs can be constructed with query parameters added to the Container's IRI is an implementation convenience, and does not imply the type of the resource.
As the IRI for Annotation Containers MAY be any IRI, and it is unlikely that every Web Server will support the functionality, it is important to be able to discover the availability of these services.
Any resource MAY link to an Annotation Container when Annotations on the resource SHOULD be created within the referenced Container. This link is carried in an HTTP Link header and the value of the rel parameter MUST be http://www.w3.org/ns/oa#annotationService.
For HTML representations of resources, the equivalent link tag in the header of the document MAY also be used.
For an example image resource, a GET request and response with a link to the above Annotation Container might look like:
Request:
Example 12
GET/images/logo.jpg HTTP/1.1
Host: example.com
Response:
Example 13
HTTP/1.1 200 OK
Content-Type: image/jpeg
Link: <http://example.org/annotations/>; rel="http://www.w3.org/ns/oa#annotationService"
Allow: GET
Content-Length: 76983
[...]
5. Creation, Updating and Deletion of Annotations
5.1 Create a New Annotation
New Annotations are created via a POST request to an Annotation Container. The Annotation, serialized as JSON-LD, is sent in the body of the request. All of the known information about the Annotation SHOULD be sent, and if there are already IRIs associated with the resources, they SHOULD be included. The serialization SHOULD use the Web Annotation JSON-LD profile, and servers MAY reject other contexts even if they would otherwise produce the same model. The server MAY reject content that is not considered an Annotation according to the Web Annotation specification [annotation-model].
Upon receipt of an Annotation, the server MAY assign IRIs to any resource or blank node in the Annotation, and MUST assign an IRI to the Annotation resource in the id property, even if it already has one provided. The server SHOULD use HTTPS IRIs when those resources are able to be retrieved individually. The server MAY also add additional information to the Annotation. Possible additional information includes the agent that created it, the time of the Annotation's creation, additional types and formats.
If the Annotation contains a canonical link, then it MUST be maintained without change. If the Annotation has an IRI in the id property, then it SHOULD be copied to the via property, and the IRI assigned by the server, at which the Annotation will be available, MUST be put in the id field to replace it.
The server MUST respond with a 201 Created response if the creation is successful, and an appropriate error code otherwise. The response MUST have a Location header with the Annotation's new IRI.
Request:
Example 14
POST/annotations/ HTTP/1.1
Host: example.org
Accept: application/ld+json; profile="http://www.w3.org/ns/anno.jsonld"
Content-Type: application/ld+json; profile="http://www.w3.org/ns/anno.jsonld"
Content-Length: 202
{
"@context": "http://www.w3.org/ns/anno.jsonld",
"type": "Annotation",
"body": {
"type": "TextualBody",
"value": "I like this page!"
},
"target": "http://www.example.com/index.html"
}
Response:
Example 15
HTTP/1.1 201 CREATED
Allow: PUT,GET,OPTIONS,HEAD,DELETE,PATCH
Location: http://example.org/annotations/anno1
Content-Type: application/ld+json; profile="http://www.w3.org/ns/anno.jsonld"
Content-Length: 287
ETag: "_87e52ce126126"
{
"@context": "http://www.w3.org/ns/anno.jsonld",
"id": "http://example.org/annotations/anno1",
"type": "Annotation",
"created": "2015-01-31T12:03:45Z",
"body": {
"type": "TextualBody",
"value": "I like this page!"
},
"target": "http://www.example.com/index.html"
}
5.2 Suggesting an IRI for an Annotation
The IRI path segment that is appended to the Container IRI for a resource MAY be suggested by the Annotation Client by using the Slug HTTP header on the request when the resource is created. The server SHOULD use this name, so long as it does not already identify an existing resource, but MAY ignore it and use an automatically assigned name.
Annotations can be updated by using a PUT request to replace the entire state of the Annotation. Annotation Servers SHOULD support this method. Servers MAY also support using a PATCH request to update only the aspects of the Annotation that have changed, but that functionality is not specified in this document.
Replacing the Annotation with a new state MUST be done with the PUT method, where the body of the request is the intended new state of the Annotation. The client SHOULD use the If-Match header with a value of the ETag it received from the server before the editing process began, to avoid collisions of multiple users modifying the same Annotation at the same time.
Servers SHOULD reject update requests that modify the values of the canonical or via properties, if they have been already set.
If successful, the server MUST return a 200 OK status with the Annotation as the body according to the content-type requested. As with creation, the server MUST return the new state of the Annotation in the response.
Clients MUST use the DELETE HTTP method to request that an Annotation be deleted by the server. Annotation Servers SHOULD support this method. Clients SHOULD send the ETag of the Annotation in the If-Match header to ensure that it is operating against the most recent version of the Annotation.
If the DELETE request is successfully processed, then the server MUST return a 204 status response. The IRIs of deleted Annotations SHOULD NOT be re-used for subsequent Annotations.
The IRI of the deleted Annotation MUST be removed from the Annotation Container it was created in.
There are no requirements made on the body of the response, and it MAY be empty.
There are inevitably situations where errors occur when retrieving or managing Annotations. The use of the HTTP status codes below provides a method for clients to understand the reason why a request has failed. Some of the situations that might occur, and the preferred HTTP status code are given below. This list is intended to be informative and explanatory, rather than imposing additional requirements beyond those already established by HTTP.
Code
Example Situation
400
The Annotation Client sent a request which the Annotation Server cannot process due to the request not following the appropriate specifications.
401
The Annotation Client is not authorized to perform the requested operation, such as creating or deleting an Annotation, as it did not supply authentication credentials.
403
The Annotation Client is not authorized to perform the requested operation, as the authentication credentials supplied did not meet the requirements of a particular access control policy for the Annotation or Annotation Container.
404
The Annotation or Annotation Container requested does not exist.
405
The requested HTTP method is not allowed for the resource, such as trying to POST to an Annotation Container page, or trying to PATCH an Annotation when that functionality is not supported.
406
The requested format for the Annotation or Annotation Container's representation is not available, for example if a client requested RDF/XML and the server does not support that (optional) transformation.
409
The Annotation Client tried to set or change a value that the server does not allow Clients to modify, such as the containment list of an Annotation Container or server set modification timestamps.
410
The Annotation is known to have existed in the past and was deleted.
412
The Annotation Client supplied an If-Match header that did not match the ETag of the Annotation being modified.
415
The Annotation Client sent an entity-body that is not able to be processed by the Server, such as non-Annotation or in a context that is unrecognized.
7. Containers for Related Resources
Annotations may have related resources that are required for their correct interpretation and rendering, such as content resources used in or as the Body, CSS stylesheets that determine the rendering of the annotation, SVG documents describing a non-rectangular region of a resource, and so forth. If these resources do not already have IRIs, then they need to be made available somewhere so that they can be referred to.
Annotation Servers MAY support the management of related resources independently from the Annotations. If a server supports the management of these resources, it SHOULD do this with one or more separate Containers. Resources that are not Annotations SHOULD NOT be included in an Annotation Container, as Annotation Clients would not expect to find arbitrary content when dereferencing the IRIs.
Containers for related resources MAY contain both RDF Sources and Non-RDF Sources. No restrictions are placed on the type or configuration of the Container beyond those of the Linked Data Platform [ldp].
Containers for related resources MUST support the same HTTP methods as described above for the Annotation Container, and MUST support identifying their type with a Link header. The constrainedBy link header on the response when dereferencing the Container SHOULD refer to a server specific set of constraints listing the types of content that are acceptable.
Use ActivityStreams based Paging mechanism to replace LDP Paging, to allow for in-page order.
Recommend the use of HTTPS over HTTP.
Rename PreferContainedURIs to PreferContainedIRIs.
Add recommendation for Accept-Post, with example.
Clarify expected status codes for successful interactions.
B. Acknowledgments
The Web Annotation Working Group gratefully acknowledges the contributions of the Open Annotation Community Group. The output of the Community Group was fundamental to the current data model and protocol.
The following people have been instrumental in providing thoughts, feedback, reviews, content, criticism and input in the creation of this specification:
Vladimir Alexiev, Art Barstow, Tim Berners-Lee, Chris Birk, Dan Brickley, Sarven Capadisli, Paolo Ciccarese, Tim Cole, Ray Denenberg, TB Dinesh, Sergiu Gordea, Benjamin Goering, Amy Guy, Ivan Herman, Frederick Hirsch, Antoine Isaac, Jacob Jett, Takeshi Kanai, Gregg Kellogg, Andreas Kuckartz, Randall Leeds, Hugo Manguinhas, Ben De Meester, Luc Moreau, Mark Nottingham, Addison Phillips, Davis Salisbury, Robert Sanderson, Felix Sasaki, Doug Schepers, Tzviya Siegman, Stian Soiland-Reyes, Manu Sporny, Nick Stenning, Jon Stroop, Lutz Suhrbier, Kyrce Swenson, Raphaël Troncy, Simeon Warner, Erik Wilde, Dan Whaley, Benjamin Young