X — Docs — Zero Human OS

Posts on X (formerly Twitter) as your own account, through a Zero Human bridge and an X app your company registers.

X is a Zero Human bridge: an MCP server Zero Human hosts in front of X's own API. You connect it on Tools in the portal by signing in with X, through an X developer app your company registers. Each post is made as your account, and X bills its API to your own app, never to Zero Human.

What a member can do

With X connected, a member can see which account it posts as, publish a post or a reply, and delete a post it made.

Tool	What it does	Reads or writes
`account_get`	The account this connection posts as: its id, handle and name	Reads
`post_create`	Publishes a post as the account, optionally as a reply to another post	Writes: a public post
`post_delete`	Deletes one post the account made	Writes: removes a post

What it writes is public: a post appears on the account as soon as post_create returns. X decides how long a post may be for the account, 280 weighted characters for most, and refuses a longer one.

It reads no timeline, mention, message or analytics, and uploads no image: a link in a post shows the page's own card.

Name each X tool a task needs, such as x.post_create, or x for all three. A tool the task does not name is refused, whatever the connection allows. A task that names a social slot's post action, rather than the tool, works with X or with any other tool that fills that slot.

Who connects it

An X connection acts as the X account that signed in when it was connected, and posts only as that account. It has no setting: the account is the sign-in's own.

You connect it by signing in with X, through your company's own X app, with four permissions: tweet.read, tweet.write (to post), users.read, and offline.access, so the connection renews itself instead of lapsing after two hours.

A connection can sit on the enterprise, a team, a member, a role or a task, and the one further down replaces the one above. A connection on anything but a task also reaches the chat of every member it covers. Connect X on the task that posts unless you want members to post from chat too.

What waits for you

In a run, a post waits for you only when the task gates it, and a Marketing task that posts gates every post. To approve each post before it goes out, gate post_create (and post_delete); see Gates and tool scopes. In a chat, both ask you before they run, unless you chose Always allow for that member and tool. account_get only reads, and never waits.

Setup

Register an X app

X bills its API to the app that made each call, so the app is your company's own, on your own X developer account.

In the X Developer Console, create a project and an app, and add API credit.
User authentication settings: turn on OAuth 2.0, with App permissions: Read and write, and Type of app: Web App (a confidential client).
Callback URI: https://portal.zerohuman.com/v1/tools/oauth/callback exactly, with no trailing slash. The Add tool form in the portal shows the right value. Website URL: your company's site.
Copy the OAuth 2.0 Client ID and Client Secret.

Connect it

Work in one browser window throughout: X returns to the portal in the window you started from.

In the portal, on Tools, choose Add tool. Layer: Task, and Bind on: the task that posts.
Kind: MCP. Tool type: x. MCP server URL: https://bridges.zerohuman.com/x/mcp.
Auth: OAuth, with your app's Client ID and Client Secret.
Permissions: choose tweet.read, users.read and offline.access from the list, and type tweet.write under Other: X's own list of permissions leaves it out, though X grants it.
Choose Connect with OAuth, check that the account on X's screen is the one that should post, and choose Authorize app.
Check it. Run a task that calls account_get. The run page shows the account's handle.

To disconnect X, delete the connection on Tools, or revoke the app under Settings → Security and account access → Apps and sessions on X. Reconnect keeps the connection and has you sign in again.

Limits and cost

X charges for each call, to your app. X's API has been pay-per-use since early 2026: your app holds credit in the X Developer Console, and each post takes some of it. A post that carries a link costs noticeably more than one that does not. The current prices are on X's own pricing page, and they are X's to change. When the credit runs out, every post is refused until more is added.

The bridge also limits each enterprise to 30 calls a minute, since every call costs money, and X's own rate limits apply on top. X refuses a post that duplicates one the account just made.

The bridge has no Zero Human charge of its own. Its calls happen inside runs, and your plan counts those runs as it counts any other.

Troubleshooting

What a call returns shows on the run page. The quoted words are taken from each message, so you can search this page for the words on your screen.

What you see	Why	What to do
The run stops and asks you to sign in again	The sign-in was revoked on X, or it was made without `offline.access` and lapsed	Choose Reconnect and sign in again, with all four permissions
The result says X "says the developer app behind this connection has no API credit left"	Your app's credit ran out	Add credit in the X Developer Console; the same post then works
The result says X "says this sign-in may not do that"	The sign-in lacks `tweet.write`, or the app's permissions are Read only	Set the app to Read and write, then Reconnect with `tweet.write` typed under Other
The result says the post "duplicates one the account already made"	X refuses the same text twice in a row	Change the words
The result says "this enterprise has made its limit of 30 calls"	The bridge's own limit, which protects your credit	Try again in a minute
The run stops and says no X connection reaches it (`tool_not_bound:x`)	X is not connected anywhere this run reaches	Connect it on the task, or at a layer the run reaches
X's screen says something went wrong before you can authorise	The app's Callback URI does not match, or OAuth 2.0 is off	Set both as Register an X app shows