Menu
Mattering Automations connector

A Prismic MCP that reaches all four Prismic APIs, not just the content feed

Connect one repository and 23 nodes land on the canvas: query published content with Prismic's whole filter grammar, read and change page types and shared slices, upload and manage media, and write documents through the Migration API. The connector fetches the content ref for you and refreshes it when a publish rotates it, so an agent can ask a real content question without anyone pasting a version string.

23 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Prismic MCP connector does

The Prismic connector for Mattering Automations is 23 nodes over 18 documented endpoints spread across four separate Prismic APIs, each on its own host: the Content API on your repository's CDN address, the Custom Types API, the Asset API, and the Migration API. Twelve nodes read and eleven act, and three are flagged destructive. The Content API is the unusual one and it is worth stating plainly, because it explains the shape of the palette: it is two endpoints, a repository root and a document search, plus a bracketed filter grammar of roughly thirty filter functions. There is no wide REST surface to slice into nodes. So the connector ships one full query node that speaks the whole grammar, five typed convenience nodes for the queries that have a natural config panel (by id, by uid, by page type with a date window, by tag, and full text), and the repository root itself.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any other MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can find the articles an editor tagged for the newsletter with Prismic: List Documents By Tag, read the page type behind them with Prismic: Get Page Type, and hand the results to the next step of a workflow, without anyone opening the Prismic dashboard. The same nodes are steps on the automation canvas, so the workflow runs on a schedule or a trigger with nobody present.

One Prismic detail usually costs people an afternoon, and the connector absorbs it. A Prismic content query is rejected without a ref, and a ref names a specific version of your content rather than being a static setting: publishing rotates it, and a stale ref answers 404 on a request that was correct sixty seconds earlier. The connector fetches the master ref itself from the repository root, caches it briefly per repository, and refreshes it automatically and retries once when a content query comes back 404 because a publish moved it. Nothing has to be pasted and nothing goes stale between publishes. Every content node still exposes an optional ref field, sourced from a picker of your repository's refs, so a workflow can deliberately read a Release instead. An explicitly chosen ref is never silently swapped for master, because substituting one would answer a different question than the one asked.

Auth has three stories in one connector and the unusual one is the default. Reading a PUBLIC Prismic repository needs no credential at all, which was verified live during the build against Prismic's own public demo repository. Reading a private repository adds a Content API access token. The other three hosts, Custom Types, Asset and Migration, need a write token minted inside that one repository. That is why the only required field on the connection is the repository name. It also means a connection with no write token is a legitimate configuration: it passes the connection test, reads content perfectly, and reports that ten of the twenty-three nodes will not run.

The safety modelling is stated rather than implied. Three nodes carry a destructive flag: Prismic: Delete Page Type, Prismic: Delete Shared Slice and Prismic: Delete Asset. None of them lands in a trash and none has a version to roll back to. Prismic's own reference warns that deleting an asset already used on published pages results in broken files, with no list of what will break. The two model deletes take the definition with them, so the honest workflow is to save the JSON first with the matching Get node, which is exactly what those node descriptions tell you to do. The Migration writes are gentler than they look for a different reason: they land as drafts in a Migration Release and change nothing live until a person publishes.

One connection, three surfaces

  • Visual automations. Drag Prismic nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Prismic node, ready to drop on the canvas

23 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 12

Prismic: Get Document By ID

Fetch one document by its Prismic id. Builds the at(document.id, ...) filter for you and returns the same paginated envelope every content query returns, with the single document in data.results[0] -- Prismic has no fetch-one endpoint, so a result count of zero is how a missing or unpublished document reports itself rather than a 404. Set lang to * if the id might belong to a translation rather than the master locale, otherwise a document that exists in another locale looks missing.

Prismic: Get Document By UID

Fetch one document by its human-readable UID, which is how a website resolves a URL slug to content. Builds the at(my.<type>.uid, ...) filter, so it needs the page type as well as the uid: a UID is unique within a page type and a locale, not across the repository. Returns the standard paginated envelope with the document in data.results[0]; zero results means no document with that uid in that type and locale. Page types with no UID field cannot be queried this way at all.

Prismic: Get Page Type

Read one page type's full definition: its label, whether it is repeatable and active, and the model JSON describing every tab, field and slice zone. RUN THIS BEFORE ANY UPDATE. Prismic's update endpoint REPLACES the model rather than merging into it and exposes no way to read a previous version, so the object this node returns is the only rollback you will have.

Prismic: Get Repository

Read the repository's metadata: every ref (the master ref for published content, plus one per Release), the page types, the tags in use, the configured locales, the bookmarks, and the query form definitions. THIS IS THE ENDPOINT THAT MAKES EVERY OTHER CONTENT QUERY POSSIBLE: a Prismic content query is rejected without a ref, and the ref lives here. The other content nodes fetch it automatically, so run this node yourself only when you want the metadata itself: to pick a Release ref, to enumerate page types or tags, or to confirm which locales exist. On a PUBLIC repository this needs no credential at all, which makes it the cheapest possible check that a repository name is right. Two convenience fields are added to Prismic's response and are not part of it: master_ref (the ref whose isMasterRef is true, lifted out so a template can reach it) and type_list (the types map turned into rows so it can populate a picker).

Prismic: Get Shared Slice

Read one shared slice's full definition, including every variation and the fields inside each. RUN THIS BEFORE ANY UPDATE: the update endpoint replaces the slice rather than merging, and no previous version is readable afterwards.

Prismic: List Assets

List the media library: each asset's id, delivery url, filename, extension, kind, size, dimensions, alt text, notes, credits and timestamps. Filter by keyword, which searches the title, filename, alt, notes and credits fields. PAGINATION IS CURSOR-BASED, not page-based: take data.cursor from one response and pass it as cursor on the next; an absent or empty cursor means you have reached the end. This is where an asset id comes from for the update and delete nodes, and for referencing media in a Migration API document.

Prismic: List Documents By Tag

List every document carrying a tag, across all page types. Tags are Prismic's repository-wide, editor-managed labels, so this is how a workflow picks up 'everything the content team marked for the newsletter' without the automation knowing anything about the content model. Give one tag, or several: match_all off returns documents with ANY of them (the any filter), match_all on returns only documents carrying ALL of them (the at filter). Tags are case-sensitive.

Prismic: List Documents By Type

List every document of one page type, optionally narrowed to a publication-date window. This is the node a content sync is built on: point it at a type, set published_after to the last time the workflow ran, and it returns only what changed since. The window filters on last_publication_date by default (what changed) or on first_publication_date (what is new), and both bounds are EXCLUSIVE, which is what makes a rolling window safe to advance without double-counting. Note that Prismic serves content from a CDN, so a document published seconds ago may not appear in the very next query.

Prismic: List Page Types

List every page type (custom type) defined in the repository, each with its id, display label, whether it is repeatable, whether it is active, and its full model JSON. This is the content model itself, not content: use it to discover what types exist before querying documents, or to snapshot the model before changing it. Requires a WRITE TOKEN even though it only reads -- the Custom Types API has no read-only credential. Returns a bare JSON array, so paths read data[].id rather than data.items[].id.

Prismic: List Shared Slices

List every shared slice in the Slice Library, each with its id, name, description and the full definition of each variation. Shared slices are the reusable page sections that page types reference in their slice zones; slices defined inline inside one page type are part of that type's model instead and do not appear here. Returns a bare JSON array, so paths read data[].id. Requires a write token even though it only reads.

Prismic: Query Documents

Query the repository with Prismic's full filter grammar. This is the connector's complete read surface: the Content API is ONE search endpoint plus a bracketed filter language, so any query Prismic can answer can be expressed here, including ones the typed nodes beside it do not cover. Give a structured filters array and the connector assembles the q parameter for you, or paste a complete q value from Prismic's API Browser into raw_query. With neither, this returns every document in the repository, newest page first. Results come back paginated with total_results_size and total_pages; each result carries its id, uid, type, tags, publication dates, locale and its full flat data object. Leave ref blank to read published content. Reads only: a Prismic filter cannot modify anything.

Prismic: Search Documents

Full-text search across the repository. Builds Prismic's fulltext filter, which searches rich text, title, key text, select and UID fields -- and only those: it does NOT search numbers, dates, links, embeds or image metadata, so a term that exists only in a caption field of the wrong type returns nothing. Leave the path at 'document' to search the whole document, or narrow it to one field with my.<type>.<field>. Optionally restrict to a single page type. Matching is by word, not by substring.

Action nodes 11

Prismic: Create Document

Create a page in Prismic from structured content. THE PAGE IS CREATED AS A DRAFT in a Migration Release and is NOT LIVE: it will not appear in any content query until somebody publishes the Migration Release from the Prismic dashboard, and the Migration API has no publish endpoint. A workflow that creates a document and then reads it back will find nothing, and that is correct behaviour rather than a failure. MEDIA MUST ALREADY EXIST: upload files with Prismic: Upload Asset first and reference them by id inside data. Rate limited to ONE REQUEST PER SECOND PER REPOSITORY, one page per request, so a bulk import needs pacing. Save the id from the response: it is what Prismic: Update Document needs.

Prismic: Create Page Type

Create a new page type from a model JSON definition. The id must not already exist: Prismic answers HTTP 409 if it does, which is a safe failure rather than an overwrite. Success is HTTP 201 with an EMPTY BODY, so this node returns no object -- confirm with Prismic: Get Page Type. Reversible with Prismic: Delete Page Type as long as no documents have been created against it yet.

Prismic: Create Shared Slice

Create a shared slice in the Slice Library. A slice needs at least one variation, each describing its own primary fields and repeatable items. Prismic answers HTTP 409 if the id already exists, so this cannot silently overwrite. Success is HTTP 201 with an EMPTY BODY. A new slice is not usable until a page type's slice zone references it, so expect a follow-up Prismic: Update Page Type.

Prismic: Delete Asset

DESTRUCTIVE and IRREVERSIBLE: remove a file from the media library. Prismic's own reference warns that deleting an asset already used on published pages RESULTS IN BROKEN FILES -- those pages keep their reference and start serving a dead URL, with no warning at delete time and no list of what will break. There is no trash and no undelete; re-uploading the same file produces a NEW id and a new URL, so existing references stay broken. Check where the asset is used before running this.

Prismic: Delete Page Type

DESTRUCTIVE and IRREVERSIBLE: delete a page type. The model definition is gone, and the Custom Types API has no trash, no versions and no undelete -- re-creating a type with the same id gives you an empty model, not the one you deleted, unless you saved the JSON first. Any documents of this type lose the model that renders and validates them. SAVE THE MODEL WITH Prismic: Get Page Type BEFORE RUNNING THIS, and prefer setting status off with Prismic: Update Page Type, which retires a type reversibly. Success is HTTP 204 with an empty body.

Prismic: Delete Shared Slice

DESTRUCTIVE and IRREVERSIBLE: delete a shared slice. The definition and every variation are gone, with no trash, no versions and no undelete, and every page type whose slice zone references it loses that option immediately. Content already authored into instances of this slice loses the model that renders it. SAVE THE DEFINITION WITH Prismic: Get Shared Slice BEFORE RUNNING THIS. Success is HTTP 204 with an empty body.

Prismic: Update Asset Metadata

Update an asset's metadata: alt text, internal notes and credits, each up to 500 characters. The FILE itself is not touched and its delivery URL does not change, so nothing already published breaks. Fields you leave blank are left alone rather than cleared. Reversible by sending the previous values back.

Prismic: Update Document

Update an existing page's content. THE UPDATE IS A DRAFT: it lands in a Migration Release and the published version is untouched until somebody publishes, so the live site does not change when this node succeeds and a content query still returns the old content. THE data OBJECT IS A FULL REPLACE, not a merge -- a field left out of it is cleared in the draft, so read the current document with Prismic: Get Document By ID and edit what it returns. Type, locale and translation link CANNOT be changed and are ignored if sent. Rate limited to one request per second per repository.

Prismic: Update Page Type

Replace a page type's definition. THIS IS A FULL REPLACE, NOT A MERGE: whatever you send becomes the entire model, so a field you leave out of the JSON disappears from the editor and the content already stored in it becomes unreachable through the app. Prismic's API offers no way to read a previous model version, so ALWAYS run Prismic: Get Page Type first and edit what it returns -- that response is your only rollback. Existing documents are not deleted and their stored values survive; re-adding the field with the same API id brings the content back. Prismic answers HTTP 422 if the id does not exist, and HTTP 204 with an EMPTY BODY on success, so this node returns no object.

Prismic: Update Shared Slice

Replace a shared slice's definition. THIS IS A FULL REPLACE, NOT A MERGE: the variations you send become the entire set, so a variation or field left out disappears and the content stored in it becomes unreachable in the editor. The API exposes no previous version, so run Prismic: Get Shared Slice first and edit what it returns -- that is your only rollback. Every page type whose slice zone references this slice is affected at once. Prismic answers HTTP 422 if the id does not exist and HTTP 204 with an empty body on success.

Prismic: Upload Asset

Add a file to the Prismic media library by URL. THE CONNECTOR FETCHES THE URL ITSELF and forwards the bytes as the multipart upload Prismic's Asset API expects, because raw file bytes cannot travel through a canvas field. The source must be publicly reachable without authentication, and the download is capped at 20 MB. Returns the created asset, whose id is what a Migration API document must reference to use the file -- the Migration API cannot upload media itself, so this node runs first in any content-with-images workflow. One asset per request and at most one request per second. Reversible with Prismic: Delete Asset.

Connecting Prismic takes one credential

The connection is built around one repository, because a Prismic write token is minted inside a single repository and is accepted by no other, and the Content API access token is likewise a per-repository setting. So the repository name is the only required field, and it is the value that builds the content host. The two tokens are both optional and they cover different halves of the connector. An access token is only needed when the repository's content is private; a public repository is readable with no credential at all. A write token is what the Custom Types, Asset and Migration APIs require, and it is created in that repository's settings under API and Security, in the Write APIs section, or from the Prismic CLI. One surprise is worth knowing before you connect: the two Custom Types listers, Prismic: List Page Types and Prismic: List Shared Slices, need the write token even though they only read, because the Custom Types API ships no read-only credential. A second one matters at debugging time: all three write hosts answer an unauthorized request with HTTP 403 and an empty body, so a token that exists but lacks privilege looks identical to a token that is wrong. Prismic's pricing page lists the Migration, Custom Types and Asset APIs as included on every plan, free included, so the write half of this connector is not plan-gated. What does vary by plan is the monthly API call allowance.

1

Find your repository name. It is the subdomain in your Prismic dashboard URL, and it is the only value the connection actually requires.

2

If the repository's content is private, create a Content API access token in that repository's settings, under API and Security. Skip this for a public repository: public reads need no credential.

3

If you want the model, media or Migration nodes, create a write token in the same settings area, under Write APIs. It belongs to this one repository and no other.

4

In Mattering Automations, open Connectors, click Add Connector, choose Prismic, and create a credential with the repository name and whichever tokens apply.

5

Click Test Connection. Mattering reads the repository root, and if a write token was supplied it also reads the Custom Types list, because that is the only thing that can prove a write token: the Content API never sees it. The success message reports the page type count so you can confirm you connected the repository you meant to.

6

All 23 Prismic nodes appear in the canvas palette. Run Prismic: Get Repository first: it returns the refs, page types, tags and locales that every picker on the other nodes reads from.

Common uses for the Prismic MCP

Ask the content model a real question, not just fetch by id

Prismic: Query Documents is the connector's complete read surface, because Prismic's read API is one search endpoint plus a filter language. Give it a structured filters array the canvas can build and template into, and the connector assembles the query for you: match a page type, exclude a tag, filter on a date, search a field, combine several at once. If you already have a query from Prismic's own API Browser, paste it whole into the raw query field instead. Beside it sit the typed nodes for the everyday cases, Prismic: Get Document By ID, Prismic: Get Document By UID, Prismic: List Documents By Type, Prismic: List Documents By Tag and Prismic: Search Documents, each of which builds its own filters so nobody has to learn the grammar to do the obvious thing.

Sync what editors published into everything else

Prismic: List Documents By Type takes a publication date window, and both bounds are exclusive, which is what makes a rolling window safe to advance without double-counting. Point it at a page type, set the start to the last time the workflow ran, and it returns only what changed. The results flow into whatever comes next: a row in a Mattering database, a task for a reviewer, a search index, a Slack message, a downstream connector. One caveat that belongs in the design rather than in a support ticket: Prismic serves content from a CDN, so a document published seconds ago may not appear in the very next query, and Prismic documents no invalidation window.

Let the content team drive an automation with tags

Tags are Prismic's repository-wide, editor-managed labels, which makes them the cleanest handoff between a person and a workflow. Prismic: List Documents By Tag picks up everything the content team marked, across every page type, without the automation needing to know anything about the content model. Ask for any of several tags, or require all of them. Tags are case sensitive, and the tag picker on the node is filled from your repository's actual tag list, so nothing is typed from memory.

Change the content model itself, with a rollback you actually have

Prismic: List Page Types, Prismic: Get Page Type, Prismic: Create Page Type and Prismic: Update Page Type cover page types, and the same four exist for shared slices. The important honesty here is about the update: it is a full replace, not a merge, and Prismic exposes no way to read a previous model version. So the pattern the nodes are built around is read first, edit what came back, send it whole. That Get response is your only rollback, which is why both update descriptions open by saying so. Content already stored in a removed field survives and reappears if the field is re-added with the same API id, which makes a careful model change far less frightening than it sounds.

Get media in before the content that references it

Prismic: Upload Asset adds a file to the media library from a public URL: the connector fetches the URL itself and forwards the bytes as the multipart upload the Asset API expects, because raw file bytes cannot travel through a canvas field. The download is capped at 20 MB and the source must be reachable without authentication. It runs first in any content-with-images workflow, because the Migration API cannot upload media and can only reference an asset that already exists. Prismic: List Assets and Prismic: Update Asset Metadata cover the rest, with cursor-based paging rather than page numbers.

Draft content from a workflow, and let a human publish it

Prismic: Create Document and Prismic: Update Document write through the Migration API, and both land as DRAFTS inside a Migration Release. The live site does not change, a content query still returns the old content, and the Migration API has no publish endpoint at all. That is the single most likely surprise with this connector, so both node descriptions lead with it. Read the other way round it is a feature: an automation can assemble a page from a source system, attach the media it uploaded a step earlier, and stop at the point where a person decides whether it goes live. Both nodes are rate limited by Prismic to one request per second per repository, one page per request, so a bulk import needs pacing.

Example: Turn a published article into everything that has to happen next

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a schedule fires every fifteen minutes.

2

Prismic: List Documents By Type runs against your article type with published after set to the last successful run. Both date bounds are exclusive, so nothing is counted twice, and the connector supplies the ref itself so the query keeps working across publishes.

3

A condition ends the run when the result count is zero, which is most of the time.

4

For each new article, the flat data object carries the fields as the model named them, so the title, summary and hero image are ordinary template paths into the next steps.

5

A Mattering database row is written or updated keyed on the document id, because a re-published article moves its last publication date forward and re-enters a later window rather than mutating an earlier one. Treat every row as an upsert on id, not an append.

6

A Slack or email node announces the article, and a task opens for whoever owns distribution.

7

Prismic: Get Page Type reads the model once a day on a separate schedule and stores the JSON, so the rollback for any future model change exists before it is needed rather than after.

Prismic MCP questions, answered

What Prismic operations are supported?

23 nodes over 18 documented endpoints across four Prismic APIs: 12 read nodes and 11 action nodes. Content: the repository root, a full filter-grammar query, and typed queries by id, by uid, by page type with a date window, by tag, and by full text. Custom Types: list, get, create, update and delete for both page types and shared slices. Assets: list, upload from a URL, update metadata, and delete. Migration: create a document and update a document. Deliberately not included, and recorded as decisions rather than gaps: Prismic's first-generation Content API, which is still live but returns a document shape a workflow cannot address cleanly; the GraphQL endpoint, whose schema is generated from your own content model rather than being a fixed vendor surface; and webhooks, which Prismic configures in the repository dashboard and exposes no REST surface to manage.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. The same 23 nodes are also steps on the automation canvas, so a workflow can run them on a schedule or a trigger with no assistant involved at all.

Does Prismic publish its own MCP server?

Prismic's published documentation does not list one. Its AI documentation covers using coding assistants with Prismic through an installable skill rather than through an MCP server, and its documentation index carries no MCP page. If Prismic ships one later, the useful distinction will be the same one that applies elsewhere: a vendor server is shaped for a developer working in an editor, while this connector is shaped for operations. These nodes run on a schedule or a trigger with nobody present, chain with every other connector in one workflow, hold the credential once in a shared workspace store rather than in each developer's local config, and carry destructive flags you can gate on.

Do I need a Prismic token at all?

Not for reading a public repository. That is unusual and it is verified rather than assumed: every content probe in this build ran with no credential and returned results. So the only field the connection actually requires is the repository name. You need a Content API access token when the repository's content is private, and you need a write token for the Custom Types, Asset and Migration nodes, which is ten of the twenty-three. A connection with no write token is a perfectly valid setup and the connection test says so in as many words rather than failing. Whichever tokens you supply, it is one credential per repository: a write token is minted inside a single repository and works nowhere else, so production and staging repositories need a connection each.

Prismic queries need a ref. Do I have to paste one in?

No, and that is the point of the design. A ref names a version of your content rather than being a setting, and publishing rotates it, so a pasted ref works until the next publish and then starts answering 404. The connector reads the master ref from the repository root itself, caches it briefly, and refreshes it and retries once when a content query 404s because a publish moved it. Every content node still has an optional ref field with a picker over your repository's refs, so you can deliberately read a Release instead of published content. When you name a ref explicitly the connector never substitutes master for it, because that would quietly answer a different question.

Can an automation publish a page in Prismic?

No, and the page would be lying if it implied otherwise. Prismic: Create Document and Prismic: Update Document write through the Migration API, and what they write is a DRAFT in a Migration Release. The published content is untouched, a content query still returns the old version, and the Migration API publishes nothing: there is no publish endpoint in it. Publishing a Migration Release is done by a person in the Prismic dashboard. A workflow that creates a document and then reads it back will find nothing, and that is correct behaviour rather than a failure. In practice this makes the write nodes a good fit for review workflows, where a human approval is wanted anyway.

Can an AI agent delete something I cannot get back?

Three nodes can, and they are flagged destructive so you can gate them: Prismic: Delete Page Type, Prismic: Delete Shared Slice and Prismic: Delete Asset. There is no trash, no version history and no undelete behind any of them. Prismic's own reference warns that deleting an asset used on published pages results in broken files: the pages keep their reference and start serving a dead URL, and re-uploading the same file produces a new id, so existing references stay broken. The two model deletes take the definition with them, and re-creating a type with the same id gives you an empty model rather than the one you deleted. The honest guardrails are structural: keep agents on the read nodes, save the JSON with the matching Get node before any model change, prefer retiring a page type by setting its status off with Prismic: Update Page Type, and put the three deletes behind a condition or an approval task.

A query that worked last week now returns an error. What changed?

Most often somebody edited a page type. This is Prismic behaviour worth knowing in advance: a typed filter aimed at a field that is missing or has the wrong type is rejected with HTTP 400 rather than returning zero results, and nothing in the error names the filter that caused it. So a number or date filter can start failing the moment its field is renamed or retyped, while the same query against an absent path with an untyped filter would simply return an empty set. Two other causes are worth checking: a hard-coded ref in the ref field breaks on the next publish, and Prismic caps a content query URL at 2048 characters, past which it answers a bare 400 that looks exactly like a syntax error. The connector enforces that length limit locally and names it rather than letting Prismic answer with an unexplained 400.

What are Prismic's rate limits?

They differ per API, which matters when you design a bulk workflow. Prismic documents the Content API at 200 requests per second, with CDN-cached queries not counted against it, and every content node in this connector targets the CDN host specifically so it sits inside that exemption. The Migration API is documented at one request per second per repository, one page per request, so an import of any size needs pacing. The Asset API is one asset per request and at most one request per second. Prismic does not document a limit for the Custom Types API. Pagination also differs: content uses a page number with a maximum page size of 100 plus a stable cursor for long walks, while assets page by cursor instead.

23 nodes waiting on the canvas

Put Prismic to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Prismic is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products