Rest API

Note: This page is a technical reference for the Rest API. If you're starting a project with Prismic, we recommend you use a user-friendly guide for the technology of your choice in our technology guides.

The Prismic Rest API is an extremely fast, flexible, and powerful engine for your content. Your API endpoint is available here:

At this endpoint, you will find the meta-information about your Prismic repository, including languages, and Custom Types. Importantly, this endpoint includes an array containing your repository's refs.

A standard content query could look like this:

Your query is defined with a query string (everything in the URL that comes after the question mark). The query string comprises name-value pairs, called parameters, which are joined with ampersands (&) and formatted as name=value. Each value is encoded using JavaScript's built-in encodeURIComponent() function.

You can use the following parameters to construct your query string:

• ref (required): A short token to specify which version of your content to query. Available at your main API endpoint.
• access_token: A long, secret string required to query private content (such as content in private repositories and drafts). Available in your Prismic repository settings.
• q: A query parameter to filter your content. If omitted, the API will return all documents.
• orderings, lang, graphQuery, etc: Option parameters to further customize your query.

Now let's break down the parameters of the above query:

The query parameter (q) accepts a set of predicates (encoded as a URI component) as its value. Each predicate is enclosed in square brackets, and the set is enclosed in square brackets.

The API will return documents that match every predicate if the set includes multiple predicates or the query string contains various query parameters.

Most predicates accept a path to denote the field being examined and then one or more values to compare in the search. The paths can take two formats, based on the predicate: document.[meta-value] or my.[custom-type].[field]. See the full path reference below.

An essential query parameter to search for a document of the type "article" will look like this:

A query parameter to search for a document of type "article," last published in 2017, will look like this:

To build your queries, we recommend using the Prismic API Browser. You can access the API Browser at https://your-repo-name.prismic.io/api/v2. (Learn more about the API Browser.)

You won't need to construct query URLs because we have development kits for the most popular web development frameworks. These kits offer helper functions for querying the API. You can learn more about querying with various technologies in our technology guides.

Here's an example of what a predicate query would look like in the API Browser, with our JavaScript kit, and as a URL:

Here is the full list of predicates:

Checks that the path matches the described value exactly. It takes a single value for a field at the top level of the document (not in Slices) or an array (only for tags).

To query by a Content Relationship, supply the document ID as the value.

Available values:

Examples:

Checks that the path doesn't match the provided value exactly. It takes a single value or an array. (Arrays are only accepted for tags.)

Accepted values:

Example:

Accepts an array of values and checks whether the fragment matches any of the values in the array. When used with the ID or UID field, it will not necessarily return the documents in the order given in the array.

Accepted values:

Example:

Checks whether a document's ID or UID is in an array of IDs or UIDs. It works the same as the any predicate but is much faster because it is only used for IDs and UIDs.

Also, unlike the any predicate, it returns the documents in the same order as the given array.

Accepted values:

Example with IDs:

Example with UIDs:

Checks if a string is found inside a whole document or within a specific field on a document.

fulltext will search for a single term, passed as a string, or for multiple terms, passed as a string of terms with spaces between them. With multiple terms, the API will return documents that contain all terms.

The search is not case-sensitive and it matches based on the root word, so a search for "Dogs" will include "dog."

The search considers Rich Text, Title, Key Text, Select, and UID fields. It ignores image alt text in Rich Text fields. It doesn't matter if the field is inside a Group, a Slice, or a Slice repeatable section.

The search is ordered by relevance, with more priority given to Rich Text content, especially headings.

Accepted values:

Example:

The has predicate checks whether a fragment has a value. It will return all the documents of the specified type that contain a value for the specified field.

Works for all content types except Groups and Slices.

Accepted values:

Example:

The missing predicate checks if a fragment doesn't have a value. It will return all the documents of the specified type that do not contain a value for the specified field.

Works for all content types except Groups and Slices.

Note that this predicate will restrict the results to the Custom Type implied in the path.

Accepted values:

Example:

The similar predicate takes the ID of a document, and returns a list of documents with similar content. This allows you to build an automated content discovery feature (for example, a "Related posts" section).

Accepted values:

Example:

The geopoint.near predicate checks that the value in the path is within the radius of the given coordinates. Distance is measured in kilometers.

The near predicate will order the results from nearest to farthest from the given coordinates.

Accepted values:

Example:

The number.lt predicate checks that the value in the Number field is less than the value passed into the predicate.

This is a strict less-than operator, it will not give values equal to the specified value.

Accepted values:

Example:

The number.gt predicate checks that the value in the Number field is greater than the value passed into the predicate.

This is a strict greater-than operator, it will not give values equal to the specified value.

Accepted values:

Example:

The number.inRange predicate checks that the value in the path is within the two values passed into the predicate.

This is an inclusive search, it will include values equal to the upper and lower limits.

Accepted values:

Example:

Prismic has sixteen predicates for dates and times.

The "after" and "before" predicates will not include a date or time equal to the given value. The "between" predicates will include dates and times equal to the given values.

Accepted values:

Here are some examples of how to use and combine date predicates:

Use the at predicate:

Combine the month and year predicates. This query will return content published in May 2017:

Most predicates accept a path to denote the field being examined. The paths can take two formats, based on the predicate: 'document.[meta-value]' or 'my.[custom-type].[field]'.

This path allows you to query a specific field in a Custom Type. [custom-type] should be the API ID of a Custom Type, such as "blog_post". [field] should be the API ID of a field in that Custom Type, such as "author".

The API ID of a document's Custom Type.

The automatically-assigned document ID, which looks like this: WGvVEDIAAAcuB3lJ

The tags assigned to a document. Tags must always be listed in an array.

The date and time that the document was first published. This value never changes.

The date and time that the document was last published. This value is updated every time new edits are published.

This path is only used with the fulltext predicate. It allows you to search all Rich Text, Title, Key Text, Select, and UID fields in a document.

Query options are formatted as name=value, where the name representing the name of the option. The value is encoded. You can encode it yourself with JavaScript's built-in encodeURIComponent() function or with a web service.

All of the query methods provided by the JavaScript-based development kits will accept an options object as an argument, like so:

This documentation is meant as a reference for the Rest API, but syntax for the JavaScript development kits is included for comparison. For more information on using query options with our JavaScript kits, see the documentation for @prismicio/client or our technology guides.

This option specifies what field to order your results by, and whether to order them ascending or descending.

Specify the field with the path my.[custom-type].[field]:

By default, the results will be ordered lowest to highest. To order results highest to lowest, add a space and desc:

To order by multiple fields, use a comma-separated list. The results will be ordered by the first path. When value of the first path is the same for multiple results, they will be ordered by the second path, and so on.

In this example, products will be sorted by price. Products with the same price will then be sorted by title.

Documents also have a first_publication_date and last_publication_date. These can also be used with orderings:

This option works with orderings to return documents after the one specified.

For example, imagine if you have a query that returns the following document IDs (in this order):

If you add the after option with the a value of "VkRmhykAAFA6PoBj", like this,

your query will return:

By reversing the orderings in your query, you can use this same method to retrieve all the documents before the specified document.

GraphQuery is an advanced query option that enables selective fetching and deep fetching. See the section on GraphQuery below.

Please note: fetch is deprecated in favor of graphQuery.

This option is used to make queries faster by only retrieving the specified field(s).

To retrieve a single field, specify it with [custom-type].[field]:

To retrieve multiple fields, use array syntax:

This option allows you to retrieve a specific content field from a linked document and add it to the document response object.

fetchLinks can not retrieve the following fields:

• Embed
• GeoPoint
• Link
• Link to Media
• Rich Text (anything other than the first element)
• Any field in a Group or Slice

To retrieve the linked content, use the format [linked-document-type].[field-on-linked-doc]:

To retrieve multiple fields, use array syntax:

This option allows you to specify what locale you would like to retrieve content from. By default, the API will return content from your master locale.

To specify a particular locale, pass the locale code:

To retrieve all locales, pass the wildcard value *:

This option defines the maximum number of documents that the API will return for your query. It accepts a number. The default is 20, and the maximum is 100.

The page option defines the pagination for the result of your query. It defaults to 1, corresponding to the first page.

GraphQuery is a query option that enables you to make advanced queries. It allows for selective fetching (only retrieving specific fields) and deep fetching (retrieving content from linked documents and Content Relationships).

Similar to the other query parameters, the format for GraphQuery is graphQuery=value. The value is an encoded GraphQuery string. You can encode the string with JavaScript's built-in encodeURIComponent() function or with a web service.

To help explain GraphQuery, we will use a concrete example of a blog. We will query a Custom Type called "post", which has some basic content: a Content Relationship for the author, a repeating Group for an image gallery, and a Slice for quotes. The author is another Custom Type, with a name, a photo, and a bio.

To select a single field, specify the Custom Type and then the field:

To select multiple fields, add more fields:

To retrieve a field in a Group, use the name of the Group and then the field:

To retrieve a field in a slice, access the body section of your Custom Type, then use ...on slice_name to access a specific slice, and then non-repeat and repeat to access to the non-repeatable and repeatable sections of the slice.

To query all fields in a document, a group, or a slice, use fragment syntax by writing ... followed by the name of the Custom Type, field, or slice section, and then Fields. In the following example, we're performing a GraphQuery operation on both the post Custom Type and the author Custom Type.

Deep fetching allows you to fetch content from a Content Relationship or Link field.

To access content from linked documents, we use the union type, ...on. With the union type, you can specify the Custom Type you want to access. The API will return the data from all documents of that Custom Type linked to your document.

You can combine deep fetching syntax with the fragment syntax to access all fields of a document plus content from linked documents.