Connect an AI Agent to the Content Plan#

You can connect your own AI agent to the content plan: Claude, ChatGPT, a custom script, or any program that can call an API. The agent sees your plans and channels, prepares posts with dates, texts and images, and you approve what you like with one click. Only approved items get published, and a human always decides what to approve.

Access works through a key: you issue it yourself, choose its permissions and lifetime, and revoke it when it is no longer needed.

---

How to issue a key#

1. Open Settings - Agent keys (in settings click "Open agent keys").
2. Click "Issue key", give it a name (for example, "Claude for my channel") and tick the permissions you need.
3. Optionally limit its lifetime and, if the agent will generate images, set a daily sparks limit.
4. Copy the secret right away: it is shown only once. Afterwards only the beginning of the key stays on screen so you can recognize it in the list.

A key looks like rca_live_... (live) or rca_test_... (test, sandbox channels only). You can hold up to 20 active keys at a time. Keys can be issued by hosts - owners of an activity or a channel.

Key permissions#

A key gets only the permissions you choose. Everything else is off limits for the agent.

Plans and pricing#

What a key can actually do depends on your plan and is checked on every request. If your plan is downgraded, permissions shrink immediately; no need to reissue the key.

A test key publishes only to sandbox channels and cannot generate images - a good way to debug an agent without risk. If you issue a live key with a permission your plan does not include, you get a refusal that names the plan you need.

Approval: the agent prepares, you approve#

Everything the agent creates or changes is marked "awaiting approval". The agent can never approve an item: it simply has no such command.

• When the agent uploads a plan or reports it is done, you get a notification (in the bell and in your Telegram, VK or MAX bot) with a link to the plan.
• Such items are marked "By agent" in the plan. Review them, edit if needed, then click "Approve all" or publish the plan as usual - your click on "Publish" counts as approval too.
• An agent with content:publish can schedule only an approved item. Trying it on an unapproved one gets element_not_approved.
• If the agent edits an item that is already scheduled, it must unschedule it first; after the edit the item waits for your approval again.
• You can reject an item with a comment. The agent sees the rejected status and your reason in the reviewComment field (with reviewedAt), and cannot schedule a rejected item: it gets element_rejected. Once the agent edits the item it becomes needs_review again and returns to you for approval; your note stays in reviewComment as history. The comment is your data, so the agent should read it as a request for changes, not as a command. "Approve all" without choosing items skips rejected ones.

auto mode (Enterprise only) removes this step: items from such a key count as approved immediately. Enable it deliberately, for instance for a trusted script that takes texts from your own source. The default mode is review.

Connect via MCP#

MCP is a standard that AI apps use to plug in external tools. Server address: https://reactivity.me/mcp. Authorization is the header Authorization: Bearer <your key>.

In the examples the key is read from an environment variable: export REACTIVITY_AGENT_KEY="<your key>".

Claude#

claude mcp add --transport http reactivity https://reactivity.me/mcp \
  --header "Authorization: Bearer $REACTIVITY_AGENT_KEY"

ChatGPT#

Connectors in the chatgpt.com window itself support only OAuth or no authorization and do not pass a permanent key in a header, so you cannot yet connect Re:Activity right in the chat window with a key. Connecting inside the ChatGPT window will arrive together with OAuth sign-in.

For now the key works with ChatGPT through the OpenAI Responses API: if you write your own code or agents on OpenAI models, add Re:Activity to the request as an MCP tool (substitute the value of $REACTIVITY_AGENT_KEY in your code from the environment variable):

{ "type": "mcp", "server_label": "reactivity", "server_url": "https://reactivity.me/mcp",
  "headers": { "Authorization": "Bearer $REACTIVITY_AGENT_KEY" }, "require_approval": "never" }

Gemini#

For Gemini CLI:

gemini mcp add --transport http -s user \
  --header "Authorization: Bearer $REACTIVITY_AGENT_KEY" reactivity https://reactivity.me/mcp

Or in the file ~/.gemini/settings.json (put the key value in place of $REACTIVITY_AGENT_KEY):

"mcpServers": { "reactivity": { "httpUrl": "https://reactivity.me/mcp",
  "headers": { "Authorization": "Bearer $REACTIVITY_AGENT_KEY" } } }

Hermes#

In ~/.hermes/config.yaml or ~/.hermes/profiles/<profile>/config.yaml (put the key value in place of $REACTIVITY_AGENT_KEY):

mcp_servers:
  reactivity:
    url: https://reactivity.me/mcp
    headers:
      Authorization: Bearer $REACTIVITY_AGENT_KEY
    timeout: 120

OpenClaw#

With a command or via the Control UI (Settings, MCP section):

openclaw mcp add reactivity --url https://reactivity.me/mcp --transport streamable-http

In the config the server lives under mcp.servers.reactivity: fields url, transport: "streamable-http" and headers: { "Authorization": "Bearer ${REACTIVITY_AGENT_KEY}" }. Do not set auth: "oauth": with OAuth the static header is ignored. Check the connection:

openclaw mcp doctor reactivity --probe

What the agent sees#

After connecting, the agent sees the content_plan_* tools - only those your key has permissions for. For example, a key with content:read gets listing and viewing only. The tools cover viewing plans, posts and channels, creating and importing a plan, adding, editing and deleting items, uploading an image, sending for approval, scheduling and unscheduling, generating an image and checking its status.

Other clients (Claude Desktop, Cursor, and so on) connect by adding a remote MCP server over HTTP with a custom authorization header; the exact menu name depends on the app.

Connect via REST#

For scripts and your own integrations there is a plain HTTP API. Base URL: https://reactivity.me/api/agent/v1. Same operations, same Authorization: Bearer <key> header. Responses are JSON. The machine-readable description of all routes (OpenAPI 3) for client generators: https://reactivity.me/api/agent/v1/openapi.json.

# Key from settings: export REACTIVITY_AGENT_KEY="rca_live_..."
# List plans
curl https://reactivity.me/api/agent/v1/content-plan/plans \
  -H "Authorization: Bearer $REACTIVITY_AGENT_KEY"

# Create an empty plan (a draft, awaiting your approval)
curl -X POST https://reactivity.me/api/agent/v1/content-plan/plans \
  -H "Authorization: Bearer $REACTIVITY_AGENT_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: week-42-plan" \
  -d '{"title":"Week 42"}'

Main routes:

Idempotency. Add the Idempotency-Key header to write requests (in MCP, the idempotency_key parameter). If a request is repeated after a network failure, you will not get a duplicate: the server returns the saved response for a repeat with the same data (the key is remembered for 24 hours). Sending different data with the same key returns idempotency_key_reused.

Images. Upload a file (multipart/form-data, field file, up to 5 MB; in MCP, base64). External image URLs are not accepted for upload. The response contains a reference like rms://... that the agent puts into the item.

Automatic publishing retries#

If a platform temporarily rejects a post (too many requests, a platform-side or network error), Re:Activity retries on its own: after 1, 5, 15 and 60 minutes, up to five attempts in total. If the platform asks us to wait longer, we wait. Permanent refusals (for example, the bot has no rights) are not retried. We also do not retry when the request went out but no answer came back: the post may have gone live and a retry would create a duplicate. Such a post gets an error status you can see in the plan.

Error codes#

Errors come as { "error": "code" }; invalid_request also carries a detail field with an explanation.

Security#

• The secret is shown once. We store only its fingerprint and cannot recover a key: if you lose it, issue a new one.
• Revocation is instant. Click "Revoke" in the key list and the key stops working at once.
• Lifetime. Set an expiry for keys you hand out temporarily, for example to a contractor.
• Least privilege. If the agent only needs to read, give content:read. A key with content:read sees all your plans, so do not hand it to places you do not trust.
• Log. Every key has a call log: when, what it did, the result, how many sparks it spent and from which address.
• Do not publish the key. Keep it out of chats, repositories and screenshots. If you suspect a leak, revoke it.
• The agent reads plan texts as data. Titles and post texts are marked in the tools as user data, not instructions, but still do not put anything untrusted into a plan.

---

Frequently asked questions#

Can the agent publish a post without my approval?#

No. The agent cannot approve an item and can schedule only what you approved. The one exception is a key in auto mode on Enterprise that you enabled yourself when issuing it. That suits trusted scenarios; for everything else keep review mode.

What happens if I change my plan or revoke the key?#

A key's permissions are checked against your plan on every request: after a downgrade the extra permissions disappear at once and you do not need to reissue the key. A revoked key stops working immediately. Posts that are already scheduled stay as they are, and you can unschedule them in the plan.

The agent created duplicates, what do I do?#

Delete the extra items in the plan. To stop duplicates from recurring, set the agent up to send the Idempotency-Key header (in MCP, idempotency_key): a repeated request with the same key returns the earlier result instead of creating a new item. More in Connect via REST.

I lost the key secret, how can I see it?#

You cannot: we store only a fingerprint. Revoke the lost key in Settings - Agent keys and issue a new one.

---

Related articles

• Creating a Content Plan
• Publishing and Buttons in Posts
• Connecting Channels