Prismic MCP Server for Claude and ChatGPT
By Prismic
Overview
Prismic is a headless CMS and agentic web platform. Connect your repository and work with your real pages, slices, and releases from Claude. Website teams use it to translate and localize published pages across locales, audit content before they archive or launch, bulk-set SEO titles and meta descriptions, roll out a messaging change everywhere it appears, and migrate content into Prismic without writing scripts. Claude reads your content model — custom types, slices, and locales — so every edit fits the structure your site already expects. It can search and inspect content across all your repositories, draft new pages, edit existing ones, and upload images. Every change lands as a draft inside a Release. Nothing is ever deleted, and nothing goes live until your team reviews and publishes it in Prismic. Free on every Prismic plan. An admin activates MCP for the repository, then you connect and sign in with your Prismic account.
How to connect
- Claude: Open the Prismic listing in the Claude connectors directory and choose Connect. Claude listing Prismic exposes 19 tools here.
- ChatGPT: Open the Prismic listing in the ChatGPT app directory and choose Connect. ChatGPT listing Prismic exposes 40 tools here.
Tools
app_get_release_publication
ChatGPTapp_track_next_step
ChatGPTarchive_documents
ChatGPTcreate_document
ChatGPTemptyContent as a starting template): - Groups: {__TYPE__:"GroupContentType", value:[{__TYPE__:"GroupItemContent", key:<uuid>, value:[[fieldName, widgetContent], ...]}]} — value is array of [fieldName, widget] TUPLES, not an object. - Slice zones: {__TYPE__:"SliceContentType", value:[{key:"<sliceId>$<uuid>", name:<sliceId>, widget:{__TYPE__:"SharedSliceContent", variation, primary:{}, items:[]}}]} — get each empty item from get_shared_slice's emptyVariations. To create a translation, pass translationOfDocumentId for any existing document in the translation group. The new document must use the same custom type and a locale not already present in that group. A deleted document still occupies its locale (even though get_document does not list it) until it is restored or permanently deleted from the Prismic dashboard. This is the only moment a document can join a group — existing documents cannot be linked afterwards. Normalization silently fixes span math, Number coercion, GeoPoint aliasing, Link key, Image edit defaults, slice item keys, and GroupItemContent shape. An Image is cropped from the rect in its url, and the server derives its edit from that rect (see get_field_shapes). If the UID conflicts, the conflicting UID is returned — pick a new one and retry. Recommend human review of the staged changes. When you created the release in this conversation and have finished writing documents into it, call present_release — do not wait for the user to ask, and do not call it for a release you did not create. Do not call publish_release unless the user asks you to.create_release
ChatGPTdelete_releases
ChatGPTtotal is 0, delete it without asking. Otherwise tell the user the release label and, for a scheduled release, its scheduled date (both from list_releases), and its number of document changes (the diff_release total); say those changes move to Archived and this cannot be undone; then ask the user to confirm, and ask once more before calling. Migration releases and releases that hold custom type or slice changes are refused. Requires the Publisher (Manager) role.diff_documents
ChatGPTdocumentId on both sides (or omit right.documentId) for a version comparison. With no versionId or releaseId, each side is the published version — unpublished drafts need releaseId or versionId. Returns a structured field-level delta in editor shape. key on links, slice items, group items and table rows/cells is stripped before comparing — it changes on every read for versions not written by a modern editor/agent, so it is never a real content difference. rightPath appears on changed and reordered entries when the compared item's identity differs between left and right; use it as the path to write back to the right document. path is for left, except on added entries where it is the right document's path. reordered means the ordered item-key list changed; before/after are those lists, the shape update_document.reorders takes. It can appear together with added/removed when items were also inserted or deleted. path is a literal nodeId looked up independently on each document (the same string on both sides). Key-qualified slice or group paths such as body[hero$uk] do not rematch across locales — they look missing on the other document. For a locale pair, omit path or pass a top-level field id. Use summaryOnly: true when the full-value payload is too large. Both sides must share a custom type.diff_release
ChatGPT{documentId, title, locale, custom_type_id, releaseVersionId, publishedVersionId?, state, deltaCount}. state is new when the document has no published version, unchanged when the staged version matches what is live, and changed otherwise. Defaults to a summary: deltaCount only. Pass summaryOnly: false for the field-level deltas of every document on the page. A delta says what the release does to what is live: before is the published value, after the staged one, added a node the release introduces and removed one it drops. Its path addresses the side the node exists on — the staged version for added, the published version for removed. changed and reordered nodes exist on both, so path is the published path and rightPath, present only when the two differ, the staged one. To write back with update_document use rightPath when it is there, otherwise path; a removed delta has no staged path to write to. total is the number of documents staged in the release; page with nextCursor until no nextCursor comes back. An entry that could not be read carries error instead of state and deltaCount, and the rest of the page is still returned. It cannot tell a document scheduled for unpublish from one being updated: that distinction is only resolved when the release is published, so a document staged for unpublish appears here as changed or unchanged like any other. The Prismic dashboard is the source of truth for unpublish intent — never tell the user a release contains no unpublishes.get_custom_type
ChatGPTemptyContent skeleton. Inlined shared slice definitions under slice zones are replaced with {type: "SharedSlice"} refs — call get_shared_slice for per-variation details. The emptyContent is a ready-to-use DocumentContent with scalar defaults applied and containers (groups, slice zones) empty. Use it as the starting point for create_document, or as a reference for valid editor-shape.get_document
ChatGPTversionId for an exact version (draft/archived/time-travel) or releaseId for the release version. A release-scoped read also returns version.stagedInRelease: when the document has no version in that release it is false and you get the published content instead, so an unstaged document reads normally rather than erroring. The returned version.id is the baseVersionId to pass to update_document, except when version.status is historical: a past version can't be a base, so stage it with restore_document_version instead. paths lists the addressable path of every field — top-level, in groups, and in slices, including fields the type allows but the document hasn't set yet — to pass to update_document's updates/deletes (read each path's current value from content). meta.alternate_languages lists linked translations as {id, locale} (omitted when the translation lookup fails). Call get_custom_type separately with meta.custom_type_id to obtain the field model. Pass path (any value from paths) to fetch just that subtree — its content and the paths nested under it — instead of the whole document. Use this for large documents whose full content gets truncated: scope to a slice (slices[<sliceKey>]) or a group field (<group>) to reveal the item keys inside it (its nested [<itemKey>] paths).get_document_publication
ChatGPTpublicationId comes from list_document_publications. Before is the previously published version, or null when this document first went live. After is null when the publication unpublished this document. Pass path to scope both sides to a subtree (same path form as get_document).get_documents
ChatGPTfields to also get the value at each path you name; without it you get metadata only. There is no whole-document option here: a page of full documents is far past what a host will show you, so name the paths you need, or call get_document for the one document you need in full. Reads the published version of each document, or its version in releaseId when you pass one (falling back to published with version.stagedInRelease: false where the release does not touch the document). There is no per-document version argument: for an exact version, a historical version, or the baseVersionId and paths needed to edit one document, call get_document. fields paths are model paths built from the type's api ids, the same grammar query_documents' where takes — meta_title, faq[].question, slices[hero].headline — not a document's instance keys (slices[hero$3f2a].headline), and whole fields only, so a path into part of one (cover{mobile}) names the field instead. A path inside a group or a repeated slice stands for every instance, so it reads back one value when the document has one and a list when it has several. At most 50 ids per call. An id that does not resolve, or a document whose content cannot be read, carries its own error and never fails the other entries; ids the repository does not know at all come back under notFound. An id under unchecked is one the lookup gave up on rather than one that is missing — read those with get_document, which looks an id up directly instead of paging the listing this tool reads. A path the type has no field for is listed in its unknownFields, so fix the path rather than reading the document; a path the type declares but this document has not filled reads back null, or an empty list where it names instances the document has none of. Each entry's own metadata, the paths, and their values all share one character budget across the call — each path costing it again for every document — so the response stays inside what a host shows: a value that no longer fits is listed in omittedFields and has to be read with get_document, and a document the page has no room left to describe carries only its id and an error saying so.get_field_shapes
ChatGPTtypes — the widget types you need (from get_custom_type) — and the tool returns only those shapes.get_shared_slice
ChatGPTemptyVariations lookup of ready-to-push slice bodies keyed by variation id. To add a slice to a document: pick an entry from emptyVariations, fill in the variation's primary/items fields, and push onto the target slice zone's value array via update_document / create_document.list_asset_tags
ChatGPTlist_custom_types
ChatGPTlist_document_publications
ChatGPTlist_document_versions
ChatGPTlist_locales
ChatGPTlist_releases
ChatGPTlist_repositories
ChatGPTlist_shared_slices
ChatGPTpresent_release
ChatGPTpublicationIntent: why this release is being published and what should be true afterwards. That intent is recorded if the user publishes.publish_release
ChatGPTpublicationIntent: why this release is being published and what should be true afterwards. The intent is recorded with every published-version change in this publication.query_documents
ChatGPTsearch_documents, results are exhaustive, not a ranked sample. Reach for this whenever the user asks for documents by a field's value or which documents use an asset. A complete query is the answer — do not follow it with search_documents to list or count the type. REQUIRE where FOR FIELD VALUES: Most field types are queryable — Select, Text, Color, Boolean, UID, IntegrationFields, Image, Embed, Link, Number, Range, Date, Timestamp and GeoPoint — top-level, inside a group, or inside a slice (its primary or items). Rich Text, Table and Separator support only has/missing. An Image field path and IntegrationFields match an opaque id (the origin asset id / the integration item id), never a URL. Image alt, credits, and named thumbnails, and Link labels and variants, use the suffixes below. Number/Range collapse spellings via JS Number ("10" and "10.0" match); Date/Timestamp collapse via Date parse to ISO, and Date eq needs a full YYYY-MM-DD — a year or year-month is INVALID_SHAPE (there is no range operator yet); GeoPoint atoms are lat,lng (latitude first, JS String of each coord) so "48.8, 2.3" matches "48.8,2.3" — GeoJSON is longitude-first and will miss. Setting only scope and skipping where returns every document of that type, which is the wrong answer to a field-value question. BUILDING A PATH (model ids only — never a document's instance keys): 1. Call get_custom_type to find the slice zone's API id (often slices, but can be anything) and the slice type id you need. Shared slices appear there as {type:"SharedSlice"} stubs. 2. Call get_shared_slice for that slice type to find the field's API id under a variation's primary or items. 3. Compose the path, dropping primary, items, and the variation id entirely: - top-level field → fieldId - field inside a group → groupId[].fieldId - field inside a slice (primary or items) → zoneId[sliceType].fieldId - field inside a group that is itself inside a slice → zoneId[sliceType].groupId[].fieldId - a nestable LegacySlice that is itself a field → zoneId[sliceType] - nested image/embed/link inside Rich Text → append {image}, {embed}, or {link} to the Rich Text path (body{image}, slices[hero].description{image}, slices[hero].description{embed}, body{link}, slices[hero].description{link}, slices[rich_text]{link}) - nested hyperlinks inside a Table → append {link} to the Table path (pricing{link}, slices[pricing]{link}). {image}/{embed} are invalid on Table. Standalone Image and Link fields do not take a nested selector (hero_image{link} and cta_link{link} are INVALID_MODEL_PATH). - image alt and credits → append @alt or @credits (hero_image@alt, body{image}@credits, slices[hero].image{mobile}@alt). @ is always last. - a named thumbnail on a standalone Image field → {name} from that field's config.thumbnails (hero_image{mobile}, hero_image{mobile}@alt). A name that is not [A-Za-z0-9_-]+ is quoted, which is how whitespace is written: hero_image{"Mobile 2x"}. There is no any-thumbnail path — OR the names from the model. Rich Text images have no thumbnails. - link label → @label (cta_link@label, body{link}@label, pricing{link}@label). @variant is only on a Link field whose model declares variants (cta_link@variant). Nested links have no variant. A variant value outside that list is INVALID_SHAPE. - an empty @alt, @credits, @label, or @variant is omitted, including on a thumbnail (hero_image{mobile}@alt, hero_image{mobile}@credits). has on hero_image and missing on hero_image@alt means the image is set and its alt is empty. A set alt, credits, label, or variant stays queryable when the asset or link target is empty. See WHERE for repeated paths. - there is no star path. To find an asset anywhere, OR every Image field with every Rich Text {image} path from get_custom_type and get_shared_slice. A slice that has both an…replace_document
ChatGPTbaseVersionId can point to any version (published, draft, archived, or from any release); the new version lands in the target release branched from that base. Use this when you're writing the document's entire content at once. To change specific fields without rebuilding the whole document, use update_document instead. For a field's exact editor shape, copy it from get_document's content or call get_field_shapes. Translation links are fixed at creation: no Prismic API can attach an existing document to a translation group. To link a standalone document, re-create it via create_document with translationOfDocumentId (copying its content) and have a human delete the original — the document id changes, so inbound links and history don't follow. If the base version changed, re-read the document and retry. Recommend human review of the staged changes. When you created the release in this conversation and have finished writing documents into it, call present_release — do not wait for the user to ask, and do not call it for a release you did not create. Do not call publish_release unless the user asks you to.restore_document_version
ChatGPTsearch_assets
ChatGPT{id, url, width, height} into ImageContent.origin when setting an image field via create_document / update_document. Pass nextCursor from a previous call to page through more results.search_documents
ChatGPTsearch_documents for semantic discovery ("find documents about pricing"), text or UID lookup, and metadata filters such as custom type, locale, status, tags, or release. - Use query_documents whenever the user asks about a field's value, which documents use an asset, or whether a field is filled. It applies exhaustive structured where filters to most field types, including nested group and slice fields. - After query_documents returns, do not call search_documents to list a custom type or to count the repository. The query result is already exhaustive. - Use get_document when you need a document's full content or when query_documents reports that the requested field operation is unsupported. SEARCH MODES IN THIS TOOL: - searchMode: "semantic" finds documents by meaning. It is the default when term is set. Results are relevance-ranked samples, never complete lists: there is no total, no pagination, and at most limit results. - searchMode: "exact" matches text or a UID literally, or lists documents selected by metadata filters. Despite its name, it does not filter document field values; use query_documents for those. RELIABLE — exact mode with filters gives a COMPLETE, deterministic list: - searchMode: "exact" with any combination of customType, locale, statuses, tags, releaseId (and an empty term) lists every document matching those filters. It is a metadata filter, not relevance ranking. - It returns total plus nextCursor. Page through by passing nextCursor back as cursor until no nextCursor comes back, then check your collected count against total. Only then can you claim you have them all. - Looking up one document: exact mode with an id or uid as term. - Limit: at most cap (1000) documents per query. If capped is true there are more matches than you can page through — narrow with filters (e.g. one locale at a time) and say so rather than reporting a partial count as the total. LISTING ONE RELEASE'S CONTENTS: - Pass releaseId (from list_releases) to scope results to the documents staged in that release. It overrides statuses — you get release-staged documents only. Use exact mode and page through every nextCursor, comparing your collected count against total. RESULTS ARE PER DOCUMENT VERSION, NOT PER DOCUMENT: - A document can appear more than once — once per status and once per release — so an id may repeat and total counts versions, not distinct documents. To count or list distinct documents, filter to a single status (e.g. statuses: ["published"]) and/or dedupe by id. FRESHNESS — the index is eventually consistent, with no guaranteed upper bound: - Writes reach the index through a batching pipeline whose configured windows alone allow ~40s (change capture up to 30s, indexing up to 7s) before embedding and write time. Under load or during a re-index it can be longer — never assume a write is immediately searchable. - So right after a batch (e.g. a localization run staging many documents into a release), a listing may be incomplete. If total is lower than expected, wait and retry before concluding documents are missing or failed. VERIFY BEFORE PRESENTING: - Nothing is post-filtered for you: a result only means the index matched your query, not that the document satisfies the user's criteria. Read each result's metadata and, when that is not enough to judge, call get_document before drawing conclusions.submit_feedback
ChatGPTdetails when they reported it; otherwise describe the problem concretely (which tool, which input, what unexpected outcome). Always set toolContext to the tool / repository / step the issue relates to when you have it. Returns a short acknowledgement. The team triages internally; no ticket id is exposed to the agent.suggest_next_steps
ChatGPTupdate_asset_tags
ChatGPTtags argument of update_document. Each name uses the tag with exactly that name, or else the one tag that differs only in case, so "hero" adds an existing "Hero" tag. An added name that matches no tag becomes a new tag. Call list_asset_tags first to reuse the repository's names. Pass at most 10 names across add and remove in one call. To tag an image while uploading it, pass tags to upload_asset instead. Repeating a call is safe. Tags cannot be deleted or renamed here, so a tag removed from every asset stays in list_asset_tags with a count of 0.update_assets
ChatGPTresults entry per item, in items order, each with its 0-based index, its id and a status: updated with the asset's alt, credits and notes after the change, or failed with the reason. The other items still apply, so retry only the failed ones. Repeating a call is safe. Editing assets needs the Writer role, so for an account without it every item fails. The change applies to future uses of the image. Pages that already use it keep their own alt text, which update_documents changes.update_document
ChatGPTbaseVersionId; the new version lands in the target release branched from that base. updates — a map of path → editor-shape value. Use the exact paths get_document returns in its paths list rather than composing them by hand — the names below are each field's API id in the type (which varies; don't assume any particular name). Path shapes: - a top-level field: <field> - a field inside a slice: <sliceZone>[<sliceKey>].<field> - a field inside a group item: <group>[<itemKey>].<field> - a whole slice <sliceZone>[<sliceKey>] or a whole group item <group>[<itemKey>] (replaces it, keeping its position) The value replaces what's at the path; a field allowed by the type but not yet on the document is added. Never target a container that holds items: a slice zone (<sliceZone>) or a group field (<group>, or <sliceZone>[<sliceKey>].<group>). Assigning to one replaces the entire list and drops every item you did not re-send, so it is rejected while the container has items. Removing one slice from a zone, or one item from a group, is a deletes call on that item's own path, never a rewrite of the container around it. Reach for the narrowest path that covers your change, and prefer several small ops over one large value. Repeatable Link/Image/Select fields and Table fields work the other way: get_document lists the field but not paths for its individual entries, so there is nothing to address with deletes and you do change one entry by sending the whole field in updates. If paths has no entry for the thing you want to remove, replacing its parent field is the intended route. deletes — a list of paths to clear (same path forms). Clearing a field removes it — the only way to clear fields with no empty value, such as images and links. A slice path removes that slice; a group-item path removes that item from its group. Slice keys are the <sliceId>$<uuid> strings and group-item keys the <uuid> strings shown by get_document; copy the exact editor-shape value get_document returns at a path and change only what you need (the __TYPE__/type discriminators are easy to get wrong). For a field/slice not yet on the document, get its shape from get_field_shapes / get_shared_slice. Items are added and reordered structurally (paths can't express insert/reorder). A container is a slice zone (<sliceZone>), a group field (<group>, or <sliceZone>[<sliceKey>].<group> inside a slice), or a slice's repeatable zone (<sliceZone>[<sliceKey>]) — each named by its API id from get_document: - inserts [{container, item, afterKey?, beforeKey?}] — add an item to a container: a slice item {name, widget} for a slice zone (clone get_shared_slice's emptyVariations), or a group item for a group. Omit both anchors to append at the end. The server assigns the new key and returns it. - reorders [{container, keys}] — keys lists all of the container's current item keys in the new order. Within one call: updates then deletes apply first, then inserts, then reorders — so a reorder's keys must match the container's items after any deletes, and don't reorder a container in the same call you insert into it. If the base version changed, re-read the document and retry. Recommend human review of the staged changes. When you created the release in this conversation and have finished writing documents into it, call present_release — do not wait for the user to ask, and do not call it for a release you did not create. Do not call publish_release unless the user asks you to. Every rejection names what was wrong and whether retrying can help. A rejected payload is rejected deterministically: resubmitting it unchanged fails identically, so change the payload (or re-read the document) first — the rejection says so when it applies. Before applying one change shape across many documents, prove it on a single document with dryRun: true, which runs every check a real call runs and writes noth…update_documents
ChatGPTdocuments names one document and its edit: documentId, baseVersionId, updates, deletes, inserts, reorders and tags. These rules apply to every entry: Only when collaborative editing is enabled: updates use current live content and autosave, and changes to list-backed fields (including slices, groups, rich text, tables and repeatable fields) are rejected before writing. Other fields and tags are supported. These live-edit restrictions do not apply to ordinary release writes with collaborative editing disabled. For live edits, the base must match an existing target's saved version; a missing target is created from the base. Detected conflicts and unsynchronized content are rejected before writing. An unconfirmed result must not be automatically retried. A dry run does not create a version or room. Untouched content is preserved from the live room for live edits, or from baseVersionId for ordinary release writes. updates — a map of path → editor-shape value. Use the exact paths get_document returns in its paths list rather than composing them by hand — the names below are each field's API id in the type (which varies; don't assume any particular name). Path shapes: - a top-level field: <field> - a field inside a slice: <sliceZone>[<sliceKey>].<field> - a field inside a group item: <group>[<itemKey>].<field> - a whole slice <sliceZone>[<sliceKey>] or a whole group item <group>[<itemKey>] (replaces it, keeping its position) The value replaces what's at the path; a field allowed by the type but not yet on the document is added. Never target a container that holds items: a slice zone (<sliceZone>) or a group field (<group>, or <sliceZone>[<sliceKey>].<group>). Assigning to one replaces the entire list and drops every item you did not re-send, so it is rejected while the container has items. Removing one slice from a zone, or one item from a group, is a deletes call on that item's own path, never a rewrite of the container around it. Reach for the narrowest path that covers your change, and prefer several small ops over one large value. Repeatable Link/Image/Select fields and Table fields work the other way: get_document lists the field but not paths for its individual entries, so there is nothing to address with deletes and you do change one entry by sending the whole field in updates. If paths has no entry for the thing you want to remove, replacing its parent field is the intended route. deletes — a list of paths to clear (same path forms). Clearing a field removes it — the only way to clear fields with no empty value, such as images and links. A slice path removes that slice; a group-item path removes that item from its group. Slice keys are the <sliceId>$<uuid> strings and group-item keys the <uuid> strings shown by get_document; copy the exact editor-shape value get_document returns at a path and change only what you need (the __TYPE__/type discriminators are easy to get wrong). For a field/slice not yet on the document, get its shape from get_field_shapes / get_shared_slice. Items are added and reordered structurally (paths can't express insert/reorder). A container is a slice zone (<sliceZone>), a group field (<group>, or <sliceZone>[<sliceKey>].<group> inside a slice), or a slice's repeatable zone (<sliceZone>[<sliceKey>]) — each named by its API id from get_document: - inserts [{container, item, afterKey?, beforeKey?}] — add an item to a container: a slice item {name, widget} for a slice zone (clone get_shared_slice's emptyVariations), or a group item for a group. Omit both anchors to append at the end. The server assigns the new key and returns it. - reorders [{container, keys}] — keys lists all of the container's current item keys in the new order. Within one call: `updat…update_draft_document
ChatGPTupdates — a map of path → editor-shape value. Use the exact paths get_document returns in its paths list rather than composing them by hand — the names below are each field's API id in the type (which varies; don't assume any particular name). Path shapes: - a top-level field: <field> - a field inside a slice: <sliceZone>[<sliceKey>].<field> - a field inside a group item: <group>[<itemKey>].<field> - a whole slice <sliceZone>[<sliceKey>] or a whole group item <group>[<itemKey>] (replaces it, keeping its position) The value replaces what's at the path; a field allowed by the type but not yet on the document is added. Never target a container that holds items: a slice zone (<sliceZone>) or a group field (<group>, or <sliceZone>[<sliceKey>].<group>). Assigning to one replaces the entire list and drops every item you did not re-send, so it is rejected while the container has items. Removing one slice from a zone, or one item from a group, is a deletes call on that item's own path, never a rewrite of the container around it. Reach for the narrowest path that covers your change, and prefer several small ops over one large value. Repeatable Link/Image/Select fields and Table fields work the other way: get_document lists the field but not paths for its individual entries, so there is nothing to address with deletes and you do change one entry by sending the whole field in updates. If paths has no entry for the thing you want to remove, replacing its parent field is the intended route. deletes — a list of paths to clear (same path forms). Clearing a field removes it — the only way to clear fields with no empty value, such as images and links. A slice path removes that slice; a group-item path removes that item from its group. Slice keys are the <sliceId>$<uuid> strings and group-item keys the <uuid> strings shown by get_document; copy the exact editor-shape value get_document returns at a path and change only what you need (the __TYPE__/type discriminators are easy to get wrong). For a field/slice not yet on the document, get its shape from get_field_shapes / get_shared_slice. Items are added and reordered structurally (paths can't express insert/reorder). A container is a slice zone (<sliceZone>), a group field (<group>, or <sliceZone>[<sliceKey>].<group> inside a slice), or a slice's repeatable zone (<sliceZone>[<sliceKey>]) — each named by its API id from get_document: - inserts [{container, item, afterKey?, beforeKey?}] — add an item to a container: a slice item {name, widget} for a slice zone (clone get_shared_slice's emptyVariations), or a group item for a group. Omit both anchors to append at the end. The server assigns the new key and returns it. - reorders [{con…update_release
ChatGPTupload_asset
ChatGPT{id, url, width, height} for ImageContent.origin in create_document / update_document. Before uploading, use search_assets to check whether the given asset already exists to prevent duplication. url is fetched server-side over HTTPS, so inline/pasted images, local files, and data/blob URIs won't work — host those first (don't ask the user). Upload to a temp file host that returns a direct file URL (e.g. tmpfiles.org), then pass that URL. When your client auto-fills file from a user upload, use it as-is — no hosting needed; don't construct file yourself.upload_assets
ChatGPTresults entry per item, in items order, each with its 0-based index and a status: - uploaded — stored, with {id, url, width, height} for ImageContent.origin in create_document / update_document; - reused — the same asset as an earlier item in the same call (identical bytes, filename, alt and credits), so it returns that item's id rather than storing a second copy; - failed — with the reason. The other items still upload, so retry only the failed ones. If an upload timed out, check search_assets first, since the library may have stored that file anyway. Each item's url is fetched server-side over HTTPS, so inline/pasted images, local files, and data/blob URIs won't work — host those first (don't ask the user). Upload to a temp file host that returns a direct file URL (e.g. tmpfiles.org), then pass that URL. An item's tags are added once it is stored, so tagging never costs it its upload: a tag that could not be added comes back as tagsError on that item, which stays uploaded with the tags that did — don't upload it again, call update_asset_tags with its id. A reused item tags the asset it reuses, so the tags of every item sharing an asset end up on it. Assets are only matched within a single call, so search_assets still tells you whether a file is already in the library. That includes after a call of yours times out, since the server goes on storing its items after you stop waiting.create_document
Claudecreate_release
Claudeget_custom_type
Claudeget_document
Claudeget_field_shapes
Claudeget_shared_slice
Claudelist_custom_types
Claudelist_document_versions
Claudelist_locales
Claudelist_releases
Claudelist_repositories
Claudelist_shared_slices
Claudepublish_release
Claudereplace_document
Claudesearch_assets
Claudesearch_documents
Claudesubmit_feedback
Claudeupdate_document
Claudeupload_asset
ClaudeLinks
Similar Apps
Listed on MCP App Store
Add this badge to your site or README. It links to this page.
HTML
<a href="https://mcp-app-store.keenethics-labs.com/app/prismic"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>
Markdown
[](https://mcp-app-store.keenethics-labs.com/app/prismic)





