Prismic Glossary

Technical procedures for communicating between two pieces of technology. Often refers to HTTP APIs on the internet, like Prismic’s, where data is sent to or retrieved from a server.

Unpublishing a Prismic document and moving it to the archive in the user interface. Archived documents are excluded from the API.

A field that stores true or false.

A field that stores a hex color code.

A reusable piece of code (.vue, .jsx, .js, .svelte, .ejs, .pug) for generating a part of a user interface.

A network of servers to distribute content globally. Prismic uses a CDN to optimize query response times.

The processes for creating and modifying the content of a website. Content management describes the policies, procedures, standards, roles, resources, and schedules to create, modify, and delete content.

Software for creating and modifying content for a website.

Creating content structures. In a Prismic repository, the largest unit of a content model is a Custom Type. Custom Types are composed of static zones and slice zones, which are composed of Fields and slices, respectively. Slices are composed of Fields. Fields are the smallest unit of a content model.

A structured field that stores internal relationships. Content relationships are designed to facilitate pulling content from another document, such as displaying related content.

A model for a type of document, (e.g. page, post, author, recipe, event). Custom types configure what fields and slices are available on a document.

Prismic’s read-write Rest API endpoint to retrieve and modify Custom Types and slices, located at https://your-repo-name.cdn.prismic.io/customtypes

The first screen you see when you log in to Prismic: a list of your repositories, located at prismic.io/dashboard

A field that stores a calendar date. The date is delivered in ISO format (YYYY-MM-DD).

Erasing a document that has already been archived. Deleted documents are not recoverable.

Publishing a website on the internet.

A unit of content in Prismic corresponding to an entity on a website (e.g., a page, post, author, tag, menu).

Prismic’s read-only Rest API endpoint for content, located at https://your-repo-name.cdn.prismic.io/api/v2/documents/search

The editor interface, where a user can edit the content of a single document.

A field that stores an oEmbed URL.

Prismic’s read-only Rest endpoint for metadata about a repository (including refs, which are necessary for requests to the Document API), located at https://your-repo-name.cdn.prismic.io/api/v2

A premium Prismic feature that allows you to clone the entirety of your production repository — including all custom types, documents, and media files — so that you can make content changes in a development environment.

The most elementary component of a Prismic model. Prismic has 18 different field types.

There are eight simple fields, which each return a primitive value (e.g. 8, false, "Dog"): UID, boolean, color, date, timestamp, number, key text, and select.

There are ten structured fields, which each return an object value: title, rich text, image, content relationship, link, link to media, embed, geopoint, repeatable group, and integration.

A field that stores a location on Earth. The location is stored as a latitude and longitude.

A data query language for APIs, created by Facebook. Gatsby uses a GraphQL API layer, and Prismic offers a GraphQL API endpoint. GraphQL stands in contrast to REST. Compared to REST, GraphQL allows for more complex querying.

Prismic’s read-only GraphQL API endpoint, located at https://your-repo-name.cdn.prismic.io/graphql

A web interface for building queries to the Prismic GraphQL API, located at https://your-repo-name.prismic.io/graphql

A log of past versions of a document in Prismic. Prismic saves all previous document versions in the history.

The former name of the rich text serializer.

A field that stores an image with cropping, alt text, and various sizes.

A field that stores data synced from a third-party API.

Prismic’s write-only Rest API endpoint to create, modify, and delete content in an integration field database, located at https://if-api.prismic.io/if/write/your-repo-name--catalog-name

A field that stores a text string without formatting.

The interface for constructing content models in the Prismic platform. The Legacy Builder is being superseded by Slice Machine and will be deprecated in the future.

A field that stores a link to the web, to media, or to an internal Prismic document. The link field is designed to facilitate creating links (hrefs).

A function that receives a document, a link field, or a content relationship field as a parameter and returns a URL path for the document.

A field that stores a link to an item in the Media Library.

A locale is a representation of the content of a Prismic repository for a specific region and language. Every Prismic repository has one “master” locale, which is the default language and region for content in the repository. Users may create additional locales and translate content into them.

The API ID for a locale. Prismic includes common locales with ISO language codes. Users can also define their own locales with custom locale codes.

The media management interface, where users can upload, delete, and select media (images, PDFs, ZIP files) and edit media’s default metadata.

JSON that imitates content from the Prismic API to simulate slices in Slice Machine.

A field that stores a number.

A variable passed into a JavaScript function. Short for “parameters.” Contrasts to "argument," which is the real value passed as a param when a function is invoked.

A search filter for the Document API.

Securely rendering unpublished content changes in Prismic live in the context of a web app.

Making a version of a document live on the Prismic API.

Sending a GET request to a Prismic repo's Document or GraphQL API to retrieve content.

An ID that is updated every time content is changed in the repository. Every repository has refs for the most recently published content, all drafts, and all releases, which are available on the Entry API. Queries to the Document API must include a ref to specify what version of the content to return. Refs enable caching, which significantly speeds up API responses. Prismic usually keeps the six most recent refs (including the current one) and deletes older ones, therefore a ref cannot be reliably used to query outdated content versions.

A release is a collection of content changes that can be previewed and published together. In a release, documents can be created, changed, or deleted.

A field that stores a repeatable set of other fields.

An isolated collection of content in Prismic. A repository stores all of the content for a project. It contains all of the documents, media, environments, translations, and settings for your project.

A standard API query language.

A graphical user interface for constructing queries to the Document API. Visit https://your-repo-name.prismic.io/api/v2 to access this.

A field that stores formatted text, images, and embeds.

A function or an object that describes how rich text elements should be rendered.

An API option that allows users to define rules for building URL paths for documents, which the Prismic API will return as the url property on each document.

How pages of a website are organized by the structure of URL paths.

A field that stores one of a collection of predefined values.

A slice is a section of a webpage. Slices are freely arranged in a document's slice zone. Each slice is rendered by a UI component in the web application (e.g. React, Vue, Svelte). Slices allow content editors to compose complex UIs.

A local development tool for developing with Prismic slices in your codebase.

The slice simulator is a mini-app that simulates what your slices will look like in production, using mock data. The slice simulator makes development faster and allows Slice Machine to take screenshots of the simulated slices to display in the Prismic editor.

A container for slices. Prismic provides SliceZone components for rendering slices in popular front-end JavaScript frameworks.

A sample project launched from the CLI.

A container for immovable and non-repeatable fields, generally used for document metadata.

The custom data format Prismic uses for rich text. Structured text is stored as JSON. Each rich text field is an array containing one object for each block-level element. The objects describe the content of the element and any inline elements. Structured text must be serialized before rendering. Prismic provides development kits for this, such as @prismicio/richtext.

Prismic’s built-in system for organizing content.

Prismic’s read-only Rest endpoint for a list of all tags used in a repository, located at https://your-repo-name.cdn.prismic.io/api/tags

Creating UI components that use data from Prismic (e.g. .vue, .jsx, .js, .svelte, .ejs).

A field that stores a calendar date and time.

A field similar to the rich text field that stores a single text heading, with formatting.

A metadata field that formats and stores a human-readable, SEO-friendly identifier for each document, unique to the Custom Type. Used for constructing URLs. Stands for “unique identifier.”

Tracking changes to work. Codebases are generally versioned with a version control system like git. Content in Prismic is versioned with the history tool. Content models in Slice Machine can be versioned as part of a codebase.

HTTPS requests sent by Prismic to a user-defined endpoint on certain actions (e.g. document published). Used to trigger actions (like a website rebuild) on content changes.