Your AI tools. Your creative workflow.

01

Add it as a custom connector

Customize, Connectors, Add custom connector, and paste this as the remote MCP server URL, exactly as written and without a trailing slash. Leave authentication on: Claude reads two documents from this server, registers itself, and sends you to sign in and approve.

https://api.postauto.io/api/mcp

02

Or open Claude with it filled in

This link opens the same form with the name and the address already typed. What you approve is scoped, and the consent screen says so in plain words. publish_post and retry_target are marked destructive, so Claude asks before either reaches a timeline.

03

Or paste a key, if the form cannot sign in

Some organisations' connector form has no sign-in for a custom server. Paste this as the server URL instead: it carries an API key in the path, authenticates exactly as a header does, and is a secret from then on. Make the key in Settings, API keys. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

https://api.postauto.io/api/mcp/pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

01

Add the server

One command, no key. Claude Code registers itself with the server and works out where to sign in on its own.

claude mcp add --transport http postauto https://api.postauto.io/api/mcp

02

Sign in

Run /mcp inside Claude Code and follow the browser. It stores the token and refreshes it when it expires, so this is the last time you think about it. From a shell instead, claude mcp login postauto does the same.

03

Or use a key, for a script with no browser

A cron job cannot follow a browser, so it wants a key instead. Make one in Settings, API keys and pass it as a header. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

claude mcp add --transport http postauto \
  https://api.postauto.io/api/mcp \
  --header "Authorization: Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

01

Turn on developer mode, then add it

Settings, Security and login, Developer mode. Then chatgpt.com/plugins, the plus button, a name and a description, and this as the MCP server URL. Choose OAuth: ChatGPT registers itself with this server and sends you to sign in. A workspace admin does the same under Workspace settings, Apps, Create, and publishes it from Drafts.

https://api.postauto.io/api/mcp

02

Write actions ask first

ChatGPT confirms write actions by default; keep that on. Everything that reads runs without a question, and the two tools that reach a timeline are marked so a client can see it.

03

Or a key, where you choose no authentication

Choose No Authentication and use this address instead: it carries an API key in the path and authenticates exactly as a header does. A published plugin cannot present a key, so this is for your own connector only. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

https://api.postauto.io/api/mcp/pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

01

Write it into mcp.json

~/.cursor/mcp.json gives every project the server, .cursor/mcp.json in a repository gives one project it. No key: Cursor speaks OAuth, opens a browser, and holds its own token. This file is safe to commit.

{
  "mcpServers": {
    "postauto": {
      "url": "https://api.postauto.io/api/mcp"
    }
  }
}

02

Or add it in one click

Cursor's own install link, carrying exactly the entry above. It opens Cursor, shows you the server, and asks before adding it.

03

Or a key in the file

The same entry with the key as a header, for a machine with no browser. A committed .cursor/mcp.json with a key in it is a published key, so ignore the file or keep this in the user scoped one. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

{
  "mcpServers": {
    "postauto": {
      "url": "https://api.postauto.io/api/mcp",
      "headers": {
        "Authorization": "Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

01

Add it to the CLI's settings

~/.gemini/settings.json for every project, .gemini/settings.json for one. httpUrl is the streamable HTTP form, which is what this endpoint speaks. With oauth enabled the CLI registers itself and /mcp auth postauto signs you in.

{
  "mcpServers": {
    "postauto": {
      "httpUrl": "https://api.postauto.io/api/mcp",
      "oauth": {
        "enabled": true
      }
    }
  }
}

02

One line does the same, and the app takes it too

This command writes the entry above. The Gemini app takes the same address under Settings & help, Connected Apps, Custom apps for Spark, Add a custom app, for personal accounts in the US for now.

gemini mcp add --transport http postauto https://api.postauto.io/api/mcp

03

Or a key in settings.json

The same entry with the key as a header, for a machine with no browser. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

{
  "mcpServers": {
    "postauto": {
      "httpUrl": "https://api.postauto.io/api/mcp",
      "headers": {
        "Authorization": "Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

01

Add a workspace server

.vscode/mcp.json, type http and the address, nothing to paste. VS Code handles the sign-in itself: a browser opens on the first connection, and the token is stored and refreshed for you.

{
  "servers": {
    "postauto": {
      "type": "http",
      "url": "https://api.postauto.io/api/mcp"
    }
  }
}

02

Or install it in one click

VS Code's own install link, carrying exactly the entry above. The server then appears in the MCP view and its tools in the chat's tool picker.

03

Or a key, prompted for and kept by VS Code

The keyed form uses an input rather than the key itself: VS Code asks for it the first time and stores it, so this file is safe to commit too. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "postauto-key",
      "description": "Postauto API key (pau_live_...)",
      "password": true
    }
  ],
  "servers": {
    "postauto": {
      "type": "http",
      "url": "https://api.postauto.io/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:postauto-key}"
      }
    }
  }
}

01

Add it to settings.json

Under context_servers, with url. Settings, AI, MCP Servers does the same from a screen. A remote server is native in Zed: with no Authorization header set, it prompts you to sign in through the standard flow the first time it connects.

{
  "context_servers": {
    "postauto": {
      "url": "https://api.postauto.io/api/mcp"
    }
  }
}

02

Nothing to bridge

An extension is only for a server that runs as a program on your machine. A remote one is added exactly as above, and that is the whole of it.

03

Or a key in the same entry

With an Authorization header set, Zed sends it and never asks you to sign in. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

{
  "context_servers": {
    "postauto": {
      "url": "https://api.postauto.io/api/mcp",
      "headers": {
        "Authorization": "Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

01

Write it into mcp_config.json

~/.codeium/windsurf/mcp_config.json, still the path the product reads under its new name. serverUrl is its word for the endpoint. Leave the headers out and Devin Desktop sends you to sign in.

{
  "mcpServers": {
    "postauto": {
      "serverUrl": "https://api.postauto.io/api/mcp"
    }
  }
}

02

Or from the panel

MCPs in the Cascade panel, or Devin Settings, Cascade, MCP Servers, takes the same address and offers the same sign-in.

https://api.postauto.io/api/mcp

03

Or a key in the same entry

Add Authorization with Bearer and your key under headers on the same entry, for a machine with no browser. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

{
  "mcpServers": {
    "postauto": {
      "serverUrl": "https://api.postauto.io/api/mcp",
      "headers": {
        "Authorization": "Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

01

Add it, then sign in

The first command writes the entry into ~/.codex/config.toml; the second opens a browser. Codex registers itself with this server and holds its own token.

codex mcp add postauto --url https://api.postauto.io/api/mcp
codex mcp login postauto

02

Or write config.toml yourself

The same entry by hand, in ~/.codex/config.toml or a project's .codex/config.toml. auth is oauth unless you say otherwise. The Codex desktop app takes the same address under Settings, MCP servers, Add server, Streamable HTTP.

[mcp_servers.postauto]
url = "https://api.postauto.io/api/mcp"

03

Or a key, for a script with no browser

Export POSTAUTO_API_KEY first; Codex reads the key from that variable rather than writing it into the file. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

codex mcp add postauto --url https://api.postauto.io/api/mcp --bearer-token-env-var POSTAUTO_API_KEY

01

Install it from Raycast

The Install MCP Server command, or Manage MCP Servers, Install New Server. Paste this as the URL, leave OAuth Type on Dynamic, press Sign In. Raycast registers itself with PKCE and stores the token encrypted. MCP is a Pro feature there.

https://api.postauto.io/api/mcp

02

Ending it is one action on either side

Logout Server in Raycast drops its token. Settings, Connected apps in Postauto ends the connection from this side, and the token stops working on the next request.

03

Or a key in the address

The form has an HTTP Headers field for a key; this address carries one in the path instead and needs no field at all. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

https://api.postauto.io/api/mcp/pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

01

Add it as a custom connector in Grok

grok.com/connectors, New Connector, Custom, and paste this as the MCP server URL. Grok discovers the tools and completes the sign-in this server asks for. The same connector works on iOS and Android.

https://api.postauto.io/api/mcp

02

From Grok Build, one command

Writes the entry into ~/.grok/config.toml. A server that signs in opens a browser on first use, and the token lives under ~/.grok. The xAI API's remote MCP tools take the same address with a key as the authorization value.

grok mcp add --transport http postauto https://api.postauto.io/api/mcp

03

Or a key, for a script with no browser

The same command with the key as a header. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

grok mcp add --transport http postauto https://api.postauto.io/api/mcp --header "Authorization: Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

01

Add it, name the auth, sign in

Three commands: the add writes the server, the configure says it signs in, the login opens a browser. openclaw mcp doctor postauto --probe afterwards says whether the tools are reachable.

openclaw mcp add postauto --url https://api.postauto.io/api/mcp --transport streamable-http
openclaw mcp configure postauto --auth oauth
openclaw mcp login postauto

02

Or in the Control UI

Settings, MCP, Add server takes the same address with transport Streamable HTTP and auth OAuth. Either way it lands in ~/.openclaw/openclaw.json under mcp.servers.

https://api.postauto.io/api/mcp

03

Or a key, for a machine with no browser

The same add with the key as a header, and no configure or login afterwards. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

openclaw mcp add postauto --url https://api.postauto.io/api/mcp --transport streamable-http --header "Authorization: Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

01

Add it to config.yaml

~/.hermes/config.yaml, under mcp_servers. Hermes connects to a remote endpoint directly and runs the sign-in on first use; the token is cached under ~/.hermes/mcp-tokens.

mcp_servers:
  postauto:
    url: "https://api.postauto.io/api/mcp"
    auth: oauth

02

Leave the confirmation on

Two tools reach real timelines and nothing can take a post back: publish_post and retry_target. Both are marked so a client can see it and ask you first. Everything else reads, or writes a draft that waits for you.

03

Or a key in the same entry

The same entry with the key as a header, for a machine with no browser. A key can publish to every channel on the account and it does not expire, so give an agent its own and revoke it in Settings, API keys when you are done.

mcp_servers:
  postauto:
    url: "https://api.postauto.io/api/mcp"
    headers:
      Authorization: "Bearer pau_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

01

Install the CLI and sign in

One package, no dependencies. auth login opens the browser, you approve, and the token stays in a file only you can read. postauto mcp is also the bridge for a client that only launches programs: it speaks stdio to the client and HTTP to us.

npm i -g postauto
postauto auth login

02

Then write a post

Every command is one tool call, so what the CLI can do is exactly what an agent can do: accounts, networks, posts, draft, publish, inbox, and call for any of the rest. Answers are JSON.

postauto draft --to <channelId> --text "Doors open at seven." --next-gate

03

Or plain HTTP, on a key

This is the shape of every MCP call, and both headers are required by the transport. It answers with the whole tool list. The REST API is the same service layer behind a different door, on the same key.

curl -sS -X POST https://api.postauto.io/api/mcp \
  -H "Authorization: Bearer $POSTAUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'