Skip to content

WEBHOOKS

Twitter Webhook API: Real-Time Post Alerts, Free to Call

The Twitter Webhook API is a free feature: register an HTTPS delivery URL, then watch an X account. Once the two are linked, every new post from that handle arrives as an HMAC-signed POST within seconds of detection, bound by a shared ~60-second poll interval. Every management call is $0; a paid monitoring plan is only needed to watch more than one account at a time. No X developer account required.

What is the Twitter Webhook API?

Two endpoints, both free. POST /twitter/webhook registers an https delivery URL and returns a signing secret shown exactly once. POST /twitter/monitor then watches an X handle. Point the monitor at your webhook's id and every new post from that account arrives as a tweet.created event, signed HMAC-SHA256 over the timestamp and raw body in an X-TwitterAPIs-Signature header. There is no backfill: only posts made after the monitor is created are delivered. An optional domain_filter narrows delivery to posts linking a given host, and include_replies (default true) can turn off reply delivery. Cost: $0 per call for every webhook and monitor endpoint. Watching a second account onward needs a monitoring plan.

What you can build with account webhooks

One webhook can receive events from every monitor you point at it. The same Bearer key and the same $0 call cost cover every pattern below.

Use caseWhat it watchesWhy it matters
Brand & mention alertingGet pushed the moment a watched competitor or partner handle postsReact in minutes, not on your next poll
Trading / alpha signalsWatch a project or founder account for launch and listing postsNo polling loop to run or rate-limit against
Support & PR triageRoute a watched account's new posts straight into a queueOne webhook receiver instead of a cron job
AI agent event feedFeed tweet.created events into an LLM classification stepPush-based, so the agent runs on new data, not a timer
Content & UGC pipelinesCatch a campaign or brand account's posts as they go liveKick off downstream clipping or repost jobs immediately

For a broader event set, mentions, replies, follows and DMs, not only new posts, see the Twitter account activity API, which covers the rest of that surface on the same polling architecture.

Register a webhook, create a monitor, verify the signature

Three calls to go live: create a webhook and save the secret it returns once, create a monitor pointed at that webhook's id, then verify the X-TwitterAPIs-Signature header on every delivery your endpoint receives.

Setup + a signature-verifying receiver

1# 1. Register your delivery URL. Save "secret" now, it is never returned again.
2curl -X POST "https://api.twitterapis.com/twitter/webhook" \
3 -H "Authorization: Bearer YOUR_API_KEY" \
4 -H "Content-Type: application/json" \
5 -d '{"url": "https://example.com/webhooks/twitterapis"}'
6# -> { "id": "wh_9f2a1c", "secret": "whsec_...", "status": "active", ... }
7
8# 2. Watch a handle and point it at the webhook you just made.
9curl -X POST "https://api.twitterapis.com/twitter/monitor" \
10 -H "Authorization: Bearer YOUR_API_KEY" \
11 -H "Content-Type: application/json" \
12 -d '{"handle": "jack", "webhook_id": "wh_9f2a1c"}'
13# -> { "id": "mon_4b1e7a", "status": "active", "poll_interval_ms": ..., ... }
14
15# 3. Fire a one-shot signed test delivery before you rely on it.
16curl -X POST "https://api.twitterapis.com/twitter/webhook/wh_9f2a1c/test" \
17 -H "Authorization: Bearer YOUR_API_KEY"
18# -> { "delivered": true, "status_code": 200, "error": null }

Every call in that setup, the webhook, the monitor, and the test send, is $0. Read the full parameter list on the Monitoring reference docs.

Three free endpoints to audit delivery, not just trust it

A push architecture is only as good as its observability. Monitoring health is exposed as data, not a support ticket, and every read below is free.

GET /twitter/monitor/{id}/health

One monitor's cursor: last tweet id seen, last poll time, and a degraded flag if it is running behind the published interval.

GET /twitter/monitor/health

Account-wide rollup, no id needed: active vs paused monitor counts, plus pending, delivered and failed deliveries over the last 24 hours.

GET /twitter/monitor/deliveries

Your most recent delivery events with real per-event detected_lag_ms and delivery_lag_ms, not a marketing average.

A real measured event from the delivery log: detection took 33,984 ms (~34 s, bound by the shared poll interval) and delivery took 3,596 ms (~3.6 s) from detection to the webhook POST landing, for about 37.6 seconds end to end. That is the honest number this feature ships with, not a best-case claim.

Every call is free. Plans cover watching more accounts.

This is the one part of TwitterAPIs that is not priced per call. Creating, updating, deleting and reading webhooks and monitors costs $0 regardless of plan. The first monitored account is free forever; watching more requires a flat monthly slot plan.

PlanPriceMonitored accounts~2 s delivery badge
Free$01 accountNo
Starter$15/mo6 accountsNo
Growth$47/mo20 accountsYes
Professional$95/mo50 accountsYes
Enterprise$199/mo150 accountsYes
Enterprise Plus$399/mo500 accountsYes
Scale$799/mo2,000 accountsYes

No API credits are ever deducted for monitoring. See live checkout and full plan detail on the pricing page's monitoring section, or explore the full API docs.

TwitterAPIs webhooks vs the official X API and self-run polling

OptionPriceAuthCoverageDelivery
TwitterAPIs monitor + webhook$0 per call, free 1-account tier, plans from $15/mo for moreBearer token, 30 s signupShared 60 s poll interval; watch a handle or a domain-filtered subsetSigned POST within ~2 s of detection (Growth plan and up)
X Account Activity API (official)Gated, paid enterprise tierX developer account, app approvalCovers mentions, replies, follows and DMs too, not just new postsStreaming only on enterprise access
Poll GET /twitter/user/mentions yourself$0.0008 per call, no subscriptionBearer token, 30 s signupYou run the loop and pay per pollAs fast as you're willing to poll

Need the wider event set, mentions, replies, follows and DMs, not just new posts, see the Twitter account activity API, which runs the same polling architecture over that broader surface.

Wire webhook events into an AI agent via MCP

Install the TwitterAPIs MCP server (@twitterapis/mcp) and webhook and monitor management become native tool calls any MCP-compatible model can invoke, create a monitor, check its health, or read recent deliveries, all in a single tool turn. Already integrated against an x_user_stream-shaped API? The oapi/x_user_stream/add_user_to_monitor_tweet compat route accepts that same request shape and resolves to the identical underlying monitor, so a migration can move at your own pace. For keyword or hashtag tracking instead of an account handle, the Twitter search API runs on the same key. To poll an account's mentions instead of pushing its new posts, use the Twitter mentions API. Need a key? Get a Twitter API key in 30 seconds.

Twitter webhook API FAQ

Two free endpoints. POST /twitter/webhook registers an HTTPS URL you control and returns an HMAC signing secret, shown once, that you use to verify deliveries. POST /twitter/monitor then watches an X account and, once you point it at a webhook, POSTs a signed tweet.created event to that URL every time the watched handle publishes. There is no backfill: only posts made after the monitor was created are delivered. Both endpoints are zero-rated, they never consume API credits.

Two separate numbers matter. Detection is bound by the shared poll interval, currently around 60 seconds across every plan and not a published SLA, so a new post can take up to about a minute to be seen. Delivery, the time from us detecting the post to our POST landing on your endpoint, is typically a couple of seconds on the Growth plan and above; on a real production event measured after shipping this feature, detection took about 34 seconds and delivery took about 3.6 seconds, for roughly 38 seconds end to end. This is a fast-polling architecture, not a firehose, and it is not marketed as sub-second push.

Every delivery is signed HMAC-SHA256 over the timestamp and the raw request body, carried in an X-TwitterAPIs-Signature header. Recompute the signature on your end using the secret returned once at webhook creation and compare it to the header before trusting the payload. A one-shot test delivery (POST /twitter/webhook/{id}/test) sends a real signed event with event set to webhook.test rather than tweet.created, so you can confirm your receiver and signature check both work before relying on it.

Creating or resuming a monitor can return 503 capacity_unavailable if the shared pool cannot currently serve one more monitor at the published interval. Retry later; this is a capacity signal, not a rejection of your account or your webhook.

No. add_user_to_monitor_tweet, remove_user_to_monitor_tweet and get_user_to_monitor_tweet are compat drop-ins that translate an x_user_stream-shaped request onto the same underlying monitor system, so a migration can point at the compat routes first and move to monitor/webhook directly on your own schedule. Both paths bill the same, which is to say nothing.

Every call to create, list, update or delete a webhook or a monitor is $0, including the health and delivery-log endpoints. What is not free is watching more than one account at a time: the first monitor on any account is a free slot, and watching more requires a monitoring plan, Starter at $15/mo for 6 slots up to Scale at $799/mo for 2,000, billed as a flat monthly subscription rather than the per-call model the rest of the API uses. See the full breakdown on the pricing page's monitoring section.

No. You need only a TwitterAPIs Bearer token, issued after a 30-second signup. There is no X developer application, no app review, and no enterprise sales process, which is the gate that keeps X's own first-party Account Activity webhooks out of reach for most builders.

Not yet through the webhook path. A monitor watches one X handle, optionally narrowed with a domain_filter (deliver only posts linking to a given host) or include_replies (turn reply delivery off). For keyword or hashtag tracking, run GET /twitter/search/tweet-advanced-search on a polling loop instead, using the same Bearer key at $0.0008 per call, see the Twitter search API.

Three read endpoints, all free. GET /twitter/monitor/{id}/health returns one monitor's cursor: its last seen tweet id, last poll time, and a degraded flag. GET /twitter/monitor/health is an account-wide rollup with no id needed, active and paused counts plus pending, delivered and failed deliveries over the last 24 hours. GET /twitter/monitor/deliveries lists your most recent delivery events with real measured detected_lag_ms and delivery_lag_ms per event, so you can audit actual latency rather than trust a published number.

Get pushed the moment an account posts

Every webhook and monitor call is $0. First account free, plans from $15/mo to watch more. No X developer account required.