How to Start With the TwitterAPIs API

The Same Call in curl, Python, and JavaScript

There is no language SDK to install. Every endpoint is plain HTTP with one Bearer header, so it works from any runtime. Here is the same advanced-search request three ways.

curl "https://api.twitterapis.com/twitter/tweet/advanced_search?query=from%3Anaval%20min_faves%3A1000&product=Latest" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

The Bearer header matches the official X API shape, so client code written against api.x.com runs here after one base-URL change to api.twitterapis.com. For the longer Python version of this snippet, with cursor pagination, retries, async, and a tweepy port, work through the Python Twitter API tutorial.

Read the Response and Page Further

A read call returns roughly 20 tweets per request inside a tweets array, plus a next_cursor string. To fetch the next page, send the same request again with cursor set to that value. Stop when the array comes back empty.

Need a single profile instead of a search? Call user/info?username=naval, also a $0.0008 read. The full endpoint reference, with every parameter and response field, lives in the API docs.

What It Costs After the Free Credits

Standard reads and simple write actions are $0.0008 per call (about $0.04 per 1,000 tweets when a call comes back with a full 20-tweet page). A few endpoints are premium: creating a tweet and the two DM reads are $0.0016, full account history (user/tweets/complete) is $0.0024, and a full thread expansion (tweet/thread) is $0.004. That is the whole price list across all 99 endpoints.

See the full breakdown on the pricing page, read how the key itself works in the Twitter API key guide, wire your key into an AI agent with the MCP server, or see how the catalog stacks up in TwitterAPIs vs twitterapi.io. If you are already calling twitterapi.io, the endpoint-by-endpoint swap is written out in the twitterapi.io migration guide.

This page is the five-minute path. The long-form version, covering auth models, every endpoint family, rate limits, and what the official API costs at each volume, is the complete Twitter API tutorial. Once reads are working, the first write most people reach for is an image post, and posting a tweet with an image covers the upload, the status poll, and the create call in order.

Coming from the official X (Twitter) API?

Most people reading a quickstart are not starting from nothing. They already have code against the official X (Twitter) API and want to know how much of it survives. The short answer is nearly all of it: the auth header is the same shape, the transport is plain HTTP, and there is no SDK to swap. Change the base URL from api.x.com to api.twitterapis.com, swap the bearer token for your key from the dashboard, and a working client keeps working.

The endpoint names differ and the mapping is close to one for one. Recent search becomes tweet/advanced_search, and it takes the same operator syntax you already write. A user lookup becomes user/info?username= or user/info_by_id. A user timeline becomes user/tweets. Followers become user/followers or user/followers_v2. Pagination is the biggest textual change: X hands you a next_token and we hand you a cursor, which you pass back on the next request until the array comes back empty. Rates on our side are $0.0008 for a standard read call rather than a per-object charge, so a call returning twenty tweets costs the same as one returning three.

One thing genuinely does not port, and it is worth naming rather than discovering. If your product signs users in with their own X accounts and acts on their behalf, that consent-bound OAuth flow belongs to X and no third-party API can legally stand in for it. Keep the official API for that path. Everything that reads public data, search, timelines, profiles, follower graphs, lists and communities, is the base-URL swap above. Most products end up running both, which is not a compromise so much as using each for what it is good at.

Pagination, Rate Limits, and Retries

A read call returns a page, not a result set, so anything beyond the first page is a loop. Page sizes differ by endpoint: a search or timeline page is around twenty tweets, while a follower or list page is larger. Send the request with no cursor to get page one, read next_cursor off the response, and send it back on the next request. For the stop condition, test has_more rather than the cursor. That matters because the two behave differently: list and affiliate endpoints do null the cursor on the last page, but follower-graph endpoints keep sending a non-null one past the end, so a loop that only checks the cursor runs forever there. has_more flips to false on the final page everywhere, so one loop works against every paged endpoint with no special case.

One key carries a ceiling of 600 requests a minute, and that number is your whole capacity plan. It is worth converting into wall clock before scheduling anything: at roughly 20 tweets a call, 600 requests a minute is about 720,000 tweets an hour on a single key. Pagination itself is sequential, because each page needs the cursor from the one before it, so extra throughput comes from working several accounts or queries concurrently rather than from splitting one loop. Run at around eighty percent of the ceiling rather than at it, since a client that sits on the limit spends its time backing off and ends up slower than one that paces itself.

Retry a 429 and a 5xx with exponential backoff and jitter. Never retry a 400, a 401 or a 404: those describe the request rather than the moment, and a retry loop on one turns a typo into a stall that ends with the same error. Failed calls are not billed, so a backoff loop costs time and not money. For any long export, checkpoint the cursor you were on. Resuming a crawl that died forty minutes in costs a few calls; restarting it costs forty minutes and the credits already spent.

Errors You Will Hit, and What Each One Means

Every error arrives as the same envelope: a machine-readable error code beside a human message, so a client branches on the code and logs the message rather than matching on prose. Five codes cover almost everything.

One habit worth adopting on day one: log the error code as a field rather than the whole message as a string. It is the difference between a dashboard that tells you a job is credit-starved and one that tells you it had 4,000 failures.

Verifying Your Setup Before You Build Anything

A first call that returns 200 proves the key works and almost nothing else. Four checks take about ten minutes on the free credit and catch the problems that otherwise surface a fortnight into a build, when they are expensive.

The whole sequence fits inside the $0.50 signup credit with room left over, which is roughly 625 calls. That is deliberate: a free tier you can only make one request on tells you nothing worth knowing.

Where to Go After Your First Call

Search is the endpoint most people start on and it is one of 99. The four below are where the majority of real integrations go next, and each is the same Bearer key and the same $0.0008 read.