API and MCP

Write access to your CMS, from the assistant you already use

One remote MCP server and one REST contract over Ghost, WordPress, Shopify and Webflow.

Install

  1. 1Create a workspace API key

    Create API key
    Why

    The key begins with sk_specter_, is shown once, and is scoped to that one workspace. It authenticates MCP and REST alike, and is revocable from the screen that made it.

  2. 2Paste the config into your assistant

    Run it in a terminal.

    terminal 
    claude mcp add --transport http spectersync https://app.spectersync.com/api/mcp \
  --header "Authorization: Bearer sk_specter_YOUR_KEY"
    Why

    Registers the server for the current project. Add --scope user to register it for every project instead.

  3. 3Ask it something read-only

    prompt 
    List my connected sites in Spectersync. Do not change anything.
    Why

    Restart the client first so it picks the server up. The prompt should call list_connections and come back with the CMSes on your workspace. A key that is wrong or revoked returns 401 instead, which tells you the same thing faster than a failed write would.

    When you ask it to change something, it drafts into a working copy and then calls create_review, which hands you one link with a card per change: before, after, and accept, reject or skip. Nothing reaches your CMS until you accept, and the link expires within a day. That is the whole publish path on the free plan — publish with confirm: true, publishing without the round trip through you, is part of Pro.

What it costs

Reading, previews and reverts are free — a rollback you have to pay for is a rollback people postpone. A refused write publishes nothing and returns the reserved credit.

Credit cost per action, and what a plan includes
Read a documentFree
Preview a publishFree
Revert to a snapshotFree
Send changes for reviewFree
Publish a document1 credit
Recipe, per document1 credit
Analysis recipe, per document2 credits
Granted at signup400 credits, once
Credit pack$29 for 400 credits, good for twelve months
Pro$99 a month — unlimited credits, fair use 5,000 documents a month
Additional user on Pro$49 a month each, same workspace
Plan detailPricing page

The safety contract

Four rules stand between an assistant and a live page.

What every write has to satisfy
The publish has to be the preview PUT defaults to dryRun: true and returns the field-level before and after plus a dryRunId. The id is bound to the whole document that would go live, and works once.
The write carries the revision you read Every publish sends back the baseVersion that came with the document. If the page moved in the CMS meanwhile, the write is refused with 409 and nothing changes.
On the free plan, a person clicks it The assistant calls create_review. Everything it staged becomes one page of before/after cards at a link you open — accept, reject with a note, or skip each one. Only an accept publishes, and it runs the same write path. Doing nothing publishes nothing, and the link expires. Publishing straight from the assistant is the Pro path.
Every publish is snapshotted first The response carries a snapshotId, and one POST puts the page back. If the snapshot cannot be saved, the publish does not happen.
Why it is built this way

Anything writing to a CMS on someone's behalf is occasionally going to be wrong, and the person who finds out is the site owner. So a preview reaches nothing on your CMS, and an edit made through any other route in between voids the id rather than riding along on your approval. The optimistic lock holds on Shopify and Webflow too, whose APIs have no such lock: Spectersync re-reads the live item and compares before writing, and a document with no recorded revision at all is refused rather than written blind. A rollback is itself snapshotted, so an unwanted rollback is recoverable as well.

The hosted MCP server carries the same guarantee. publish is the only tool that writes to a live CMS, and it needs confirm: true, the base_version the agent read, and a dry_run_id from its own prior preview of that exact document. An agent cannot reach your site on one tool call, and it cannot reach it with a document other than the one you were shown.

Limits and errors

v1 reads and updates content that already exists; the rest stays in the web app.

Limits
Create, delete, upload mediaWeb app only — not over API or MCP
Webflow SEO metaWritten when the collection carries a conventionally slugged field (meta-title / seo-title, meta-description / seo-description) or one is mapped in config. Webflow has no reserved SEO surface on CMS items, so a collection without such a field has nowhere to put them
Review linkOne to twenty-four hours, twenty-four by default. At expiry the link, the batch and the staged edits it froze are all deleted; snapshots of anything published are kept
Request budget60 a minute per key, counted per server instance
Snapshot retention7 days on free and credit packs, 90 on Pro. The most recent snapshot of a document is never deleted, so a revert is always available
Per-platform detailCapability matrix
Every non-2xx response has the shape { "error": { "type", "message" } }
401 Missing, unknown or revoked key
402 Out of credits, past the fair-use ceiling, a tool your plan does not include, or use_review_url — this plan publishes through a review link. Nothing written, the CMS was never contacted
404 No such site, post or snapshot
409 Refused, nothing written — details.reason says which
422 Body off contract, or a publish with no baseVersion or dryRunId
429 Over the request budget
502 The CMS refused the write

REST and OpenAPI Not live yet

Every /v1 path below returns 404 today. Read it as the contract to build against — the same code path as MCP, so the same guarantees.

request 
Authorization: Bearer sk_specter_…
Base URL       https://app.spectersync.com/api
Endpoints
POST /v1/reviews Turn the staged edits into one link a person approves on
GET /v1/reviews/{id} What they accepted, what they rejected, and the comment on each
GET /v1/sites Connected CMSes, with what each one's write lock guarantees
GET /v1/sites/{site}/posts Documents on a site — filter by kind, status or title
GET /v1/sites/{site}/posts/{post} Markdown, frontmatter, what is live, and the baseVersion
PUT /v1/sites/{site}/posts/{post} Preview by default; publishes on dryRun: false
POST …/snapshots/{snapshot}/revert Put the CMS back to a snapshot

The body is markdown and the frontmatter has the same nine fields on every platform, so you build against one contract instead of four APIs. Full detail is in /api/v1/openapi.json — OpenAPI 3.1, generated from the schemas the endpoints validate against.

Questions before you connect

Which clients work today?
Claude Code, Claude Desktop and Cursor are the three we have run against the live endpoint. The endpoint is a plain remote MCP server, so the same key works from Windsurf, Gemini CLI, Antigravity, Devin, VS Code Copilot and Codex CLI — each of those blocks was written from that client's own current docs and is tagged as not yet run here. ChatGPT is the one that cannot: its custom connectors authenticate over OAuth or not at all, never with a bearer key, and Spectersync issues keys. OAuth is what closes that gap.
How does publishing work on the free plan?
Your assistant stages the edits, then calls create_review. That returns one link — no login — with a card per changed page: the before and after, the checks we ran, and accept, reject or skip. Accepting runs the same publish path as the paid route, snapshot and revision lock included. A rejection can carry a note, which the assistant reads back through review_status so it can redo the edit. The link is a capability: anyone holding it can approve those changes, so treat it like a password. It expires within a day, and at expiry the staged edits go with it. confirm: true — publishing without the round trip through a human — is part of Pro.
Where do my CMS credentials go?
Into the workspace, encrypted at rest with AES-256-GCM under a server-held key, and never into the conversation. Your assistant sees markdown, frontmatter and diffs. Delete a connection and its credentials go with it.
What can the assistant actually change?
The ten editable fields the markdown contract covers — title, slug, status, tags, excerpt, feature image, author, body, meta title and meta description. Not themes, plugins, members, customers, orders or newsletters.
How do I undo something?
Every publish returns a snapshotId. POST …/snapshots/{id}/revert republishes the state from before, and returns an undoSnapshotId for the state that rollback replaced.
Can I revoke a key?
From the same screen that made it. Keys are stored as a SHA-256 hash, scoped to one workspace, and never shown again after creation. Call the API from your server: the authenticated REST endpoints deliberately send no CORS headers, because the only way to call them from a browser is to ship the key to it.
Why is REST not live yet?
The MCP endpoint shipped first because that is what an assistant connects to. REST is the same code path behind a different door, and the OpenAPI document is generated from the same schemas, so the contract on this page is what it will answer with.
Create API key See the demo