Connect social platforms

Connecting a social platform is more work than pasting an API key. Each wants a developer account and an app registered against a callback URL, one charges per post, and one refuses to connect until you have invited yourself as a tester. None of it is hidden here.

If that reads like more setup than the question is worth, it probably is. Publish by hand instead: it measures just as well and needs no account anywhere.

Two accounts, not one

Every social connection has two roles, usually two different accounts.

• The app owner registers the application and carries whatever it costs.
• The acting account is the one whose handle appears on the post.

Make the acting account your brand account: it is the handle readers see, and a post under somebody’s personal one cannot be unsent. Keep the app on a company account too, because charges land on whoever owns it, not on whoever authorized it.

They drift apart because they are set at different moments: the app once, by whoever was logged in, and the acting account much later, on the consent screen. Read that screen before approving it.

What each platform costs and measures

Platform	What it costs	What it collects
X	$0.20 per post containing a link, $0.015 without one, $0.005 per engagement read	impressions, likes, comments, shares, clicks
Threads	Free, capped at 250 posts per 24 hours	impressions, likes, comments, shares

Marketing posts carry links, so quote yourself the $0.20 rate, never the headline one. A two-week, two-post experiment costs about a dollar: forty cents of posting, the rest in engagement reads every six hours per published asset.

What a platform collects decides which questions it can answer. Threads reports no clicks, so an experiment on clicks runs on X and not Threads. The metric select says so up front, disabling any metric nothing can collect.

Connect X

1. Sign up for an X developer account as the account that will own the app.
2. Turn on pay-per-use under Billing and add credit. No subscription, no minimum: X charges you per post and per read, and stops the calls when the credit runs out.
3. Create an app with read and write permissions, and enable OAuth 2.0.
4. In CommandChain, import X from the catalogue in Settings → Integrations, open it, and go to Connections. The redirect URL for this workspace is shown there. Copy it and register it on the app, unchanged.
5. Paste the app’s client id and secret into the same panel and press Connect with OAuth2.
6. Authorize as the brand account. The consent screen names the account it will act as, so switch there if it is wrong.

Every approval to publish through X carries the spend, so cost is visible when you decide.

Connect Threads

A Threads account is built on an Instagram account, and its API belongs to a Meta app.

1. Create a Meta app and add the Threads use case. Take the Threads-prefixed app id and secret from that use case’s own settings: the app’s general credentials are a different pair the Threads API will not accept.
2. Invite the acting Threads account as a tester and accept the invitation from it. Until the app passes Meta’s review only invited testers can connect, and a missing invitation fails with a permissions error that never mentions testers.
3. Register the one redirect URL. Threads accepts exactly one, it must be https, and Meta matches it character for character, so copy it from the Connections tab rather than retyping. Two traps: the field only saves when you click the suggestion that drops down under it, and an instance not reachable over https needs a tunnel in front of it first.
4. Import Threads and connect. Publishing takes two calls, create the post then release it, and the approval renders both.

Connect anything else

Nothing above is special-cased: X and Threads ship pre-built because they are common, not because they are wired in. Any platform with an HTTP API takes the same path through the integration registry: describe the API, give it a category, let the proposed bindings map your operations onto its endpoints, verify each against the live service, activate.

A verify is a real call

Verification calls the endpoint for real, so the first live call happens while you watch. On a metered platform the publish check stays request-shaped: it posts nothing and costs nothing.

Publish by hand instead

An integration makes the loop automatic. It is not what makes the loop work: starting without one is a legitimate way to run this, not a consolation.

Agents draft as usual. On the asset, Copy for posting puts the text on your clipboard and runs the brand check beside it. Paste it into your own account, Mark as published with the post URL, then open the experiment and use Record results to type in the numbers the platform showed you.

Those numbers are first-class: they feed baselines, evidence, and verdicts exactly like collected ones, and the verdict says it was measured from manually recorded numbers. Leave a running manual experiment unmeasured for three days and one reminder task appears, linking straight to the entry form. The full loop is on Run marketing experiments.

Next steps

• Run marketing experiments: why most people connect a platform.
• The integration registry: credentials, connections, bindings, activation.
• Autonomy for marketing actions: what an agent may post unasked.