Writing with your own AI over MCP

Let Claude or another MCP client write from the content queue: claim topics, read briefs, send drafts, translations and covers, or run unattended on a Mac.

The content engine has a second writer: your own AI. Any MCP client signed in to AutoPSEO, such as Claude Code, the Claude apps or Cursor, can take topics from the same queue, read the same brief and rules, and submit drafts that pass the same checks as AutoPSEO's writer. Drafts written this way do not count against the monthly article quota. You can work with it in a chat, or let an unattended run write on a schedule.

Connect your AI

The MCP endpoint is https://app.autopseo.com/mcp. There are two ways in, both on the MCP & API page of your account:

Sign in with OAuth under "Connect by signing in". In Claude Code: claude mcp add --transport http autopseo https://app.autopseo.com/mcp, then /mcp and Authenticate.
An API key starting with apk_live_, sent as Authorization: Bearer <key>. Content tools that change anything need a Read & write key; a Read only key reaches only the read tools.

Your role matters too: a member with view access can only use read tools, and a member invited to some properties sees only those. The full catalogue, including the Search Console tools, is on the MCP page; key management is in MCP & ChatGPT app.

Under Settings on the Content page, Who writes the topics in the queue decides who works the queue: AutoPSEO, at the pace above or Your own AI, through MCP. With your own AI chosen, AutoPSEO's writer stops taking queued tasks. Either way, "Your own AI can write and rewrite articles at any time, whichever you choose here." To claim and submit, the engine must be on for the property and the plan active.

The content tools

Tool	Access	What it does
`content_instructions`	read	The whole of one unattended run for a property, built from its settings
`content_report`	read	Settings, content types, quota, task counts, the 20 newest live articles and refused deliveries
`content_list_tasks`	read	Tasks, most promising first, with who holds each
`content_find_pages`	read	Pages of your site that match a query, to check coverage and pick links
`content_get_page`	read	An article's live text, its draft under review, its revisions and its searches over 28 days
`content_get_translation`	read	One language: the original, the translator's rules and the current translation
`content_get_brief`	paid	The writing rules, the brief, the links allowed, a typed page's address and whether a cover is wanted
`content_add_topics`	write	Plan 1 to 200 topics; they go through the gates and the review
`content_claim`	write	Hold a task for two hours: by task, by page (`rewrite`, `optimize` or `refresh`) or by keyword
`content_submit`	write	Check and save a draft; nothing is saved while errors remain
`content_submit_translation`	write	Check and save one language of a draft or a live article
`content_cover`	write	Check a scene and get the image prompt, references and an upload address
`content_set_cover`	write	Set or replace a cover, or get an upload address for one
`content_publish`	write	Approve a draft, or put back an earlier revision
`content_unpublish`	write	Take an article down
`content_merge`	write	Merge an article into another page, with a 301
`content_decline`	write	Turn a task down for good, with a reason
`content_propose_value`	write	Propose a new value for a typed content type, after asking your site
`content_submit_value`	write	Send a new value's facts for review
`content_remove_path`	write	Ask your site to take a value's path down

A read-only key, or a member with view access, is refused by every tool that is not read. The tools that publish, take down, merge or remove a path tell the AI to act only with your go-ahead.

Write an article

Pick a task. content_list_tasks shows what is queued; content_find_pages checks whether your site already covers it.
Claim it. content_claim { taskId } holds the task for two hours, and claiming again renews the hold. You can also claim a live article with pageId and kind, or start from a keyword, optionally with a content type key. A keyword goes through the gates first.
Read the brief. content_get_brief returns rules (the same writing rules AutoPSEO's writer gets), the brief, allowedLinks, and cover.wanted. The first call researches the search results and costs research credits; later calls for the same task are free.
Write and submit. Send the article as JSON in the format described in delivery with content_submit. If it fails a check, the answer starts "Not saved. Fix these and submit again:" with the list; links outside allowedLinks are turned into bold text. When the task changes a live article, pass baseRev, the revision you worked from; if the article moved on, the submit is refused as a conflict.
Translate. For each other language, content_get_translation, then content_submit_translation. Languages can be sent in parallel. See translation.
Add a cover when the brief says one is wanted (below).
Publish. The draft waits in review. content_publish { taskId } approves it, which the tool reserves for when you say so.

A hold that runs out is released by the five-minute schedule: the task goes back to the queue. content_decline turns a task down for good with a reason of 3 to 300 characters, so it is never proposed again.

Revise a draft in review

When a reviewer asks for changes, nobody needs to turn the draft down:

content_claim with the task (or the page, or the keyword) takes your draft back to writing, so nobody publishes it meanwhile.
content_get_page returns the draft as draft.
content_submit saves the next revision at the same address and marks the old draft as replaced.
Send the translations again: the new revision holds only its own language, and content_get_translation offers the replaced draft's translation as current.

If the hold runs out first, the draft goes back to review unchanged.

Prompts

The server also offers prompts, which appear in Claude Code as slash commands such as /mcp__autopseo__write-articles:

Prompt	Arguments	What it walks through
`write-articles`	`site`, `count` (1 to 10)	Writing articles from the queue, step by step
`revise-draft`	`site`, `draft`, `changes`	Revising a draft that waits in review
`optimize-page`	`site`, `page`	Improving one live article
`refresh-decayed`	`site`, `limit` (up to 10)	Refreshing articles that lost clicks
`connect-repo`	`articlesUrl`	Building the signed webhook receiver in your site's code

Covers from your own AI

When your site shows covers, content_get_brief says cover.wanted. Your AI can hand over an image it made with content_submit's cover (an https url, or base64 data up to 2.5 MB), PUT the file to the coverUploadUrl that content_submit returns, or set it later with content_set_cover. It can also draw from AutoPSEO's own prompt with content_cover. Formats, sizes and checks are in covers.

What it costs

Drafts and translations from your own AI do not count against the monthly article quota, and sending them is free.
The brief's first look at the search results, and the model call that picks a content type for a keyword two types could take, use research credits.
Adding topics, declining and the read tools are free. Approving a draft that lacks languages, on a site where AutoPSEO translates, starts translations on research credits.

Unattended runs on a Mac

content_instructions returns everything one unattended run should do for a property: report, finish what an earlier run left, check coverage before spending on a brief, decline duplicates, write, translate, add covers, and publish only when the site's review is off. It never takes articles down or rolls them back, and it ends with one line a script can read:

AUTOPSEO_RESULT property=<id> published=<n> review=<n> declined=<n> failed=<n> values=<n>

The AutoPSEO writer is a small set of macOS scripts that runs this with your own Claude Code on your own Claude subscription, under launchd. Contact us to get them. Setup:

Connect Claude Code to AutoPSEO (the connector in Claude, or claude mcp add --scope user --transport http autopseo https://app.autopseo.com/mcp and Authenticate under /mcp).
Run ./install.sh. It creates ~/.autopseo/ with run.sh, cover-mcp.mjs and a sample writer.json, and a launchd job that runs daily at 15:07 (AUTOPSEO_HOUR and AUTOPSEO_MINUTE change it). The job is not loaded yet.
Fill in ~/.autopseo/writer.json: properties (each id, with an optional limit of new articles per run, default 8, at most 20), model and fallbackModel, an optional subagentModel for the translation subagents, everyDays between runs of a property (default 3), and covers (codex,grok, or off).
Try one run: AUTOPSEO_FORCE=1 ~/.autopseo/run.sh, then read ~/.autopseo/logs/history.log.
Load the schedule with launchctl load ~/Library/LaunchAgents/com.autopseo.writer.plist.

Each run starts one claude -p per property, allowed to use only the AutoPSEO tools and subagents: no shell, no files, no web. A run counts as a success only when it prints the result line. When values is above 0, a second session takes the new paths of typed pages: it may search and read the web, but only reaches the tools a value task needs. Runs that fail for a passing reason are retried up to three times, a usage limit stops the remaining properties, a watchdog ends a run after five hours, and the Mac is kept awake meanwhile.

For covers, the scripts hand Claude Code a second MCP server with one tool, make_cover, which draws AutoPSEO's prompt with the Codex CLI (signed in with ChatGPT) or the Grok CLI, each in its own sandbox, and uploads only to app.autopseo.com.

To have only your own AI write, choose Your own AI, through MCP as the writer and keep New articles per week above 0. The pace also drives the daily review and top-up that fill the queue, so at 0 no new topic reaches it.