ENGAGEMENT
Twitter Engagement API: Like, Repost and Measure
Updated July 2026
How do you like or repost a tweet with an API?
A Twitter engagement API has two halves. The write half performs the interaction itself, so your code can like, repost, bookmark, follow or publish as a real X account. The read half returns the counters those interactions move on any public post. TwitterAPIs covers both on one Bearer key, with five write actions and their matching undo calls at $0.0008 each, after a free one-time session registration.
We bill each engagement action at $0.0008 (source: our published pricing), the same flat rate as a standard read.
Every engagement action, and the call that reverses it
Each interaction is one POST, and each one has a mirror that undoes it at the identical price. That symmetry matters more than it looks: it means a bad run is cheap to unwind, and a dry-run mode in your own code is trivially reversible.
| Action | Endpoint | Reverse it with | Per call | Docs |
|---|---|---|---|---|
| Like a post | POST /twitter/tweet/favorite | POST /twitter/tweet/unfavorite | $0.0008 | View docs |
| Repost a post | POST /twitter/tweet/retweet | POST /twitter/tweet/unretweet | $0.0008 | View docs |
| Bookmark a post | POST /twitter/tweet/bookmark | POST /twitter/tweet/unbookmark | $0.0008 | View docs |
| Follow an account | POST /twitter/user/follow | POST /twitter/user/unfollow | $0.0008 | View docs |
| Publish a post | POST /twitter/tweet/create | POST /twitter/tweet/delete | $0.0016 | View docs |
Publishing is the single premium write at $0.0016. Everything else on this table, including the undo calls, bills at the standard $0.0008 read rate.
One free setup call before your first like
A read works on your Bearer token alone, because public data is not attributed to anybody. A write has to act as somebody. So you register an X session once with POST /twitter/customer/session, handing over auth_token and ct0 from the account you control. That call is free, the session is stored against your API key, and every later write is applied as that account with no further arguments. There is no OAuth consent screen and no app review anywhere in this path.
Register once, then like a post
# 1. Register your X session once. This call is free.
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
"https://api.twitterapis.com/twitter/customer/session" \
-d '{"auth_token":"YOUR_AUTH_TOKEN","ct0":"YOUR_CT0"}'
# 2. Like a post. $0.0008.
curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
"https://api.twitterapis.com/twitter/tweet/favorite?id=1234567890"import requests
BASE = "https://api.twitterapis.com"
HEAD = {"Authorization": "Bearer YOUR_API_KEY"}
# Register the acting account once. Free.
requests.post(
f"{BASE}/twitter/customer/session",
json={"auth_token": "YOUR_AUTH_TOKEN", "ct0": "YOUR_CT0"},
headers=HEAD,
)
def like(post_id):
res = requests.post(
f"{BASE}/twitter/tweet/favorite",
params={"id": post_id},
headers=HEAD,
)
return res.json()
def unlike(post_id):
res = requests.post(
f"{BASE}/twitter/tweet/unfavorite",
params={"id": post_id},
headers=HEAD,
)
return res.json()
print(like("1234567890"))const BASE = "https://api.twitterapis.com";
const HEAD = {
Authorization: "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
};
// Register the acting account once. Free.
await fetch(`${BASE}/twitter/customer/session`, {
method: "POST",
headers: HEAD,
body: '{"auth_token":"YOUR_AUTH_TOKEN","ct0":"YOUR_CT0"}',
});
async function like(postId) {
const res = await fetch(
`${BASE}/twitter/tweet/favorite?id=${postId}`,
{ method: "POST", headers: HEAD },
);
return res.json();
}
async function unlike(postId) {
const res = await fetch(
`${BASE}/twitter/tweet/unfavorite?id=${postId}`,
{ method: "POST", headers: HEAD },
);
return res.json();
}
console.log(await like("1234567890"));Both id and url are accepted on the like and repost calls, so you can pass a raw post link straight through without parsing an ID out of it first.
Reading engagement without touching the post
Reporting work never needs a session. These four calls run on your Bearer token alone, modify nothing, and attribute nothing to you.
| Signal | Endpoint | Docs |
|---|---|---|
| Like, repost, reply and quote counts on one post | GET /twitter/tweet/detail | View docs |
| The accounts that reposted a given post | GET /twitter/tweet/retweeters | View docs |
| Everything a specific account has liked | GET /twitter/user/likes | View docs |
| The reply thread under a post | GET /twitter/tweet/replies | View docs |
One gap worth naming plainly: X does not expose the list of accounts that liked a post to third parties, so neither do we. The reverse lookup is available instead, reading what a given account has liked. The repost list is the closest thing to a public audience roster, and pulling a tweet's full retweeter list walks the cursor loop that pages past the first response, in Python and Node.js, with the per-call cost of a viral post worked out.
How to check your Twitter analytics with the API
For one post, GET /twitter/tweet/detail returns its public counters in a single call: likes as favorite_count, reposts, replies, quotes, bookmarks and, where X exposes it, views as view_count. For a whole account, page GET /twitter/user/tweets instead. Every post on the page arrives with the same counters, so one call covers about twenty posts rather than one, and a month of analytics for an active account is usually a handful of calls.
From there the arithmetic is yours: engagement per post, engagement rate against views or against followers, and the median across the last thirty posts as the baseline a new post is judged against. The engagement rate calculator shows each formula on a single post, and the Twitter analytics API page covers reporting across accounts and keywords, including which measurements are public and which stay with the account owner.
Track campaign tweets over time
A campaign report built from one reading at the end tells you where each post finished, not how it got there. Read the counters on a schedule instead and store every reading, and you get a curve per post: how fast it picked up, when it stalled, and whether a repost from a large account moved it. Read often while a post is new and back off once its counters stop moving.
Read timelines rather than single posts when you can. Ten creators posting for a campaign, each timeline read hourly for a week, is 10 times 168, or 1,680 calls, about $1.34, and it catches every campaign post without you knowing the IDs in advance. Filter on your hashtag or link in your own code. Reading 30 known posts one at a time on the same schedule would be 5,040 calls, about $4.03, for less coverage. The guide to tracking a tweet's performance in real time builds the polling loop and the storage for this.
Inspect the audience behind the engagement
Counters say how much engagement a post drew; they do not say from whom. GET /twitter/user/audience_summary samples between 10 and 100 of an account's followers, or of one post's reposters when you pass a tweet_id, and returns a country histogram of where those accounts say they are based. It also counts how many sampled accounts show each of seven documented profile signals and how many show three or more, as likely_bot_count.
Treat that last number as a reason to look, not a verdict on any account: it is a heuristic over profile fields, and the response says so. It is billed per item at $0.0008, and the default 50-account sample needs 53 items of balance up front, about four cents. Running it on the reposters of a campaign post is the quickest way to see whether the amplification came from the market you were paying to reach.
Real engagement, not vanity metrics
A like is the cheapest thing a viewer can give, and the easiest to buy. The counters that are harder to fake are the ones that cost the viewer something: a reply means they wrote words, a quote means they put their own name on a reaction, and a bookmark means they meant to come back. Report those beside likes, and divide by views where the post has them, so a post shown to ten times as many people does not look ten times better.
Then compare each post with the same account's own median rather than with a number from somewhere else. A post far above its account's median likes with an ordinary reply count is worth a second look, and the reposter list from GET /twitter/tweet/retweeters usually explains it, whether as one large account that shared it or a cluster of new, quiet accounts that all arrived at once.
Business impact metrics from engagement data
Engagement becomes a business number when you join it to something the business already counts. Three joins cover most reporting. Response time: read the replies under posts that mention you and measure how long your account took to answer, which is a support metric built entirely from public timestamps. Conversation rate: replies per post across a month, which tracks whether an audience talks back. And share of voice: your mentions against your competitors' over the same window, covered on the social listening use case.
Traffic and revenue sit outside any public counter. Link clicks and profile visits are owner-only figures that X keeps in its own analytics, so tag the links in your posts with campaign parameters and read the visits in your own web analytics. Joined on the post's date and link, that gives you engagement and outcome on one row, which is the version of the report a budget owner actually reads.
A write costs the same as a read
$0.0008
per like, repost, bookmark, follow, or undo
$0.0016
to publish a post, the one premium write
$0
to register your session, and no monthly fee
A thousand likes is about $0.80. An idle script costs nothing, because nothing bills until a call is made. Compare the whole endpoint table on the Twitter API pricing page, or size a monthly budget with the Twitter API cost calculator.
Related surfaces on the same key
To aggregate the counters rather than move them, the Twitter analytics API covers reporting over a whole account or keyword. Following and unfollowing sit next to the rest of the graph on the Twitter followers API. For the request shape, auth header and error handling behind all of these, read the Twitter REST API overview, and to drive engagement from an AI agent, connect the MCP server.
By the numbers
Engagement access, in numbers.
Sourced figures behind write-action pricing.
The official X API prices pay-per-use writes at $0.050 per post created, well above the third-party rate for the same action. (X Developer Platform, 2026)
Official X API write endpoints are capped per 15-minute and per 24-hour window, with limits that vary by access tier. (X API docs, 2026)
TwitterAPIs bills likes, reposts, bookmarks, follows and every undo call at a flat $0.0008, the same rate as a standard read. (TwitterAPIs pricing, 2026)
Session registration is a single free call that stores auth_token and ct0 against your API key and applies to every later write. (TwitterAPIs docs, 2026)
A new account starts with $0.50 in free credit and no card on file, which covers roughly 600 engagement actions. (TwitterAPIs pricing, 2026)
Engagement API, common questions
A Twitter engagement API is a REST interface with two halves. The write half performs the interactions themselves, so your code can like, repost, bookmark, follow or publish as a real X account. The read half returns the counters those interactions move, so you can measure like, repost, reply and quote totals on any public post. TwitterAPIs covers both on a single Bearer key: five write actions with matching undo calls at $0.0008 each, and four read endpoints at the same standard rate, with no X developer account and no monthly plan.
Yes, and this is the one setup step people miss. A read works on your Bearer token alone, because public data is not attributed to anybody. A write has to act as somebody, so it needs an X session. You supply auth_token and ct0 once through POST /twitter/customer/session, which costs nothing, and the session is stored against your key and applied to every subsequent like, repost, bookmark, follow and post. There is no OAuth consent screen and no app review in the path.
Yes, and it needs no session at all. GET /twitter/tweet/detail takes a post id or url on your Bearer token and returns the like, repost, reply, quote, bookmark and view counters on that post. Nothing is attributed to you and nothing is modified. That call is the right one for dashboards, leaderboards and reporting, where you want the number without touching the post.
For the views shown on any public post, including your own, call GET /twitter/tweet/detail with the post id or url and read view_count, beside the like, repost, reply, quote and bookmark counters. Treat view_count as optional, because it is populated only when X exposes it for that post. To see views across a whole account, page GET /twitter/user/tweets, which returns the same counters on every post, about twenty per call. What no API returns is the owner-only breakdown X keeps in its own analytics for the account holder, such as profile visits and link clicks, so for those you open X's analytics for the account itself. And do not use follower count as a stand-in for impressions: a post can be shown to far more people than follow the account, or to far fewer, which is why views, where present, are the better denominator for an engagement rate.
Automation that a real person has authorised on their own account is ordinary API use; bulk unsolicited interaction is what platform policy targets, and X enforces against it regardless of which tool produced it. Two practical consequences. Register only sessions for accounts you actually control, and pace your write volume to look like a person rather than a loop. Our per-call billing means throttling costs you nothing, so there is no commercial reason to run hot.
Send POST /twitter/tweet/favorite with either the post id or its url as a query parameter, carrying your Bearer token. Because a like has to be attributed to a real account, you register your X session once beforehand with POST /twitter/customer/session, supplying auth_token and ct0. That registration call is free and is stored against your API key, so every later write is applied as your account automatically. Undoing is the mirror call, POST /twitter/tweet/unfavorite, at the same $0.0008.
Likes, reposts, bookmarks, follows and every matching undo bill at a flat $0.0008 per call, the same rate as a standard read, so a write costs you no more than a read. Publishing a post is the one premium write at $0.0016. Registering your session is free. There is no monthly minimum and no seat licence, which means a thousand likes costs about $0.80 and a script that idles costs nothing at all.
Reposts, yes. GET /twitter/tweet/retweeters pages through the accounts that reposted a given post, each with its profile fields, so you can profile who amplifies a topic. The list of accounts that liked a post is not exposed by X to third parties in the same way, so we do not offer it. The nearest available angle is the reverse lookup: GET /twitter/user/likes returns what a specific account has liked, which answers audience questions from the account side rather than the post side.
It is the read side of this page pointed at people instead of posts. An influencer API returns a creator's profile, recent posts with their engagement counters, and their follower graph, which is everything needed to judge whether an account has a real, engaged audience in your category. Here that is GET /twitter/user/info for the profile, GET /twitter/user/tweets for recent posts, GET /twitter/user/followers for a follower sample, and GET /twitter/user/audience_summary for a country histogram and a profile-signal count over a sample of followers. Each read is $0.0008. There is no influencer score in the response, by design: you compute engagement rate and reply ratio yourself and rank a shortlist on your own criteria. The influencer discovery use case walks through sourcing and vetting a list end to end.
Like and repost from your own code
$0.0008 per action, free session setup, $0.50 in signup credit. Five write actions, each with a matching undo.
Next read
Continue exploring related pages:
Twitter analytics API
Engagement counts, profile counters and post history as JSON.
Twitter followers API
Export any account's followers and following with cursor pagination, $0.0008 a call, $0.04 per 1,000 tweets on full 20-tweet pages.
Twitter REST API
The auth header, paging model and error contract in one place.
Twitter account activity API
Watch mentions, follows and DMs without enterprise webhooks.