TwitterAPI.io vs TwitterAPIs: what each workload costs, limits and how to switch

Where TwitterAPI.io costs less, on real traffic

A rate card says little until it meets real traffic. We took the requests our customers actually make, grouped them into workloads, and priced the average request in each on both services. The table shows the workloads where TwitterAPI.io is lower, and the last row prices the whole request mix, every request included.

The biggest row decides the total. More than a third of all requests are monitoring checks that find nothing new, and those cost $0.00015 here against $0.0008. Profile lookups and tweet details by ID, together about a quarter of requests, also cost about half as much per request.

How each one bills

Every bill on either service is number of requests × price per request. The price per request is where they differ, and the number of items a request returns is what moves it.

TwitterAPIs uses a flat rate. Its pricing page (twitterapis.com/pricing) lists $0.0008 per call for the standard tier, which covers 65 of its 112 endpoints, and the other 47 endpoints, mostly write actions, at $0.0016 to $0.01 (full history $0.0024, full threads $0.004), with a few batch endpoints priced per item. A call that returns 20 tweets and a call that returns none cost the same.

TwitterAPI.io uses credits: 100,000 credits are $1. Tweets cost 15 credits each and profiles 18, with a 15-credit minimum per request. There is no per-request cap. The formula is:

request = max(15, 15 × tweets returned) credits · 100,000 credits = $1

So a request that returns 5 or fewer tweets costs less on TwitterAPI.io than one $0.0008 call, and a check that returns nothing costs $0.00015. Subscriptions lower our price further: our plans convert the fee to credits and add extra credits on top (14% in the first month on Builder, 50% on Business, plus a monthly return), so $1 buys 1.22× the credits on Builder and 1.9× on Business.

Price per data type

A single “per 1,000 tweets” number hides most of the difference, because per-call and per-result billing price each endpoint differently. This table prices the kinds of data where TwitterAPI.io is lower the way you would actually fetch them, at pay-as-you-go prices. Green marks the lower price on each row.

Items per page: TwitterAPI.io returns up to 200 followers per page and 20 verified followers per page; TwitterAPIs' followers page (twitterapis.com/twitter-followers-api) states about 70 per page. Per-1,000 figures for TwitterAPIs are $0.0008 divided by items per call. TwitterAPI.io prices are from our pricing page; TwitterAPIs prices from its pricing page (twitterapis.com/pricing), checked in 2026.

What a month costs: four jobs

Four common jobs, each costed on both services with the arithmetic shown, so you can swap in your own numbers. Prices are pay-as-you-go unless a row says otherwise.

Keyword alert, polled every 60 seconds

43,200 checks a month; 90% find nothing, 10% find 3 tweets

TwitterAPI.io38,880 × $0.00015 + 4,320 × $0.00045 = $7.78

TwitterAPIs43,200 × $0.0008 = $34.56

New posts from 200 accounts, hourly (from:handle since_id search)

144,000 searches, about 1 new tweet each

TwitterAPI.io144,000 × $0.00015 = $21.60

TwitterAPIs144,000 × $0.0008 = $115.20

Enrich 100,000 profiles

by user ID in batches of 100+

TwitterAPI.io100,000 × $0.00001 = $1.00 (or $18.00 one by one)

TwitterAPIs100,000 × $0.0008 = $80.00

Export 1 million followers

200 per page here; ~70 on the first page there, fewer after

TwitterAPI.io5,000 pages × $0.002 = $10.00

TwitterAPIs$12–$16 (its stated $0.012–$0.016 per 1,000)

The pattern is consistent. Anything that repeats a query and usually finds little (alerts, monitoring, brand mentions, new posts from a list of accounts) costs several times less on TwitterAPI.io, because an empty check is $0.00015 instead of a full call. So does anything about users rather than tweets.

Poll accounts for new posts at the minimum price

Most account polling is really asking “has this account posted anything new?”, and on TwitterAPI.io that question costs least as a search that returns only the new tweets. A query like from:nasa since_id:<last id> returns only the new tweets: $0.00015 when nothing is new, $0.0003 for two, against $0.0008 per call on TwitterAPIs.

import os, time, requests

KEY = os.environ["TWITTERAPI_IO_KEY"]
HANDLES = ["nasa", "spacex", "esa"]  # accounts to watch
since = {h: None for h in HANDLES}

def check(handle):
    # the first run (no since_id yet) returns up to 20 recent tweets
    q = f"from:{handle}" + (f" since_id:{since[handle]}" if since[handle] else "")
    r = requests.get("https://api.twitterapi.io/twitter/tweet/advanced_search",
                     headers={"X-API-Key": KEY},
                     params={"query": q, "queryType": "Latest"}, timeout=30)
    if r.status_code == 429:
        time.sleep(int(r.headers.get("Retry-After", 1)))
        return []  # try this account again next round
    r.raise_for_status()
    tweets = r.json().get("tweets", [])
    if tweets:
        since[handle] = max(tweets, key=lambda t: int(t["id"]))["id"]
    return tweets  # billed per tweet returned; a check with nothing new is the 15-credit minimum

while True:
    for h in HANDLES:
        try:
            for t in check(h):
                print(h, t["id"], t["text"][:80])
        except requests.RequestException as e:
            print("skipped", h, e)  # network error or 5xx: retry next round
    time.sleep(3600)  # hourly; 3 accounts x 720 checks = 2,160 checks a month

Two caveats. Search results can arrive a little later than the timeline, so test the delay on your own accounts before relying on it for alerts measured in seconds. And if you need every reply and repost an account makes, compare the results with the timeline once before switching.

Features and limits

TwitterAPIs figures from its pricing (twitterapis.com/pricing), rate-limit (twitterapis.com/twitter-api-rate-limits) and MCP (twitterapis.com/mcp) pages; TwitterAPI.io from our pricing, rate limits and MCP server pages. Checked in 2026.

Rate limits in practice

TwitterAPIs gives every key the same ceiling, 600 requests a minute with 20 in flight, whatever you spend. TwitterAPI.io starts new, unpaid accounts at 0.2 requests per second, raises every account to 20 per second after the first payment, and goes to 50 on the Scale plan and 500 on Business. Your normal load rarely touches either ceiling. Backfills do, so size the limit for the backfill: at 20 per second you can fetch about 1.7 million search pages a day, at 10 per second about 860,000.

Real-time delivery

Both services can push data instead of making you poll. TwitterAPI.io runs keyword filter rules on its side and delivers matches by webhook or WebSocket, billed at the same rate as polling the search yourself; see the webhooks guide. For a fixed list of accounts, Twitter Stream costs $29 a month for 6 accounts (+$5 per extra account), $79 for 20, $149 for 50, $299 for 150 and $499 for 500, and adds accounts one at a time at $5 down to $1 each. TwitterAPIs' account monitors come in fixed tiers with no per-account add-on, so a count just above one of its tiers needs the next one: at 7–9, 21–23, 51–66, 151–199 and 501–799 accounts, Twitter Stream costs less.

AI agents and MCP

TwitterAPI.io's MCP server has 12 read-only tools (search, users, followers, replies, trends) as an npx package. For an agent that reads, a short tool list is easy for the model to choose from, and exploratory queries that return little stay cheap at $0.00015 each.

Write actions

Both support posting, liking, reposting and following on an account you control. TwitterAPI.io's write endpoints take login cookies from its login endpoint plus a proxy. TwitterAPIs uses an auth_token and ct0 cookie pair, or a credential login for which it recommends a residential proxy. Either way, automated actions on an X account can get it limited, so keep them human-paced.

The same request on both

The read endpoints share the /twitter/... path layout, so a search is the same request with a different host, header and one parameter name:

# TwitterAPI.io
curl -H "X-API-Key: $TWITTERAPI_IO_KEY" \
  "https://api.twitterapi.io/twitter/tweet/advanced_search?query=from%3Anasa&queryType=Latest"

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

TwitterAPIs request and response fields from its quickstart (twitterapis.com/quickstart). Compare the fields inside each tweet object for the endpoints you use before moving production traffic.

One adapter for either provider

If you want to run both, or keep the option to move, put the four differences in one place. This TypeScript generator pages through a search on either service and backs off and retries on 429:

// One client, either provider. Only the base URL, auth header,
// search parameter and end-of-results flag differ.
type Provider = "twitterapi.io" | "twitterapis"

const CONFIG = {
  "twitterapi.io": {
    base: "https://api.twitterapi.io",
    headers: (key: string) => ({ "X-API-Key": key }),
    sortParam: "queryType",
    hasMore: (body: any) => Boolean(body.has_next_page),
  },
  twitterapis: {
    base: "https://api.twitterapis.com",
    headers: (key: string) => ({ Authorization: `Bearer ${key}` }),
    sortParam: "product",
    hasMore: (body: any) => Boolean(body.has_more),
  },
} as const

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))

export async function* searchTweets(provider: Provider, key: string, query: string, maxPages = 10) {
  const c = CONFIG[provider]
  let cursor = ""
  for (let page = 0; page < maxPages; page++) {
    const params = new URLSearchParams({ query, [c.sortParam]: "Latest" })
    if (cursor) params.set("cursor", cursor)
    let res: Response
    for (let attempt = 0; ; attempt++) {
      res = await fetch(`${c.base}/twitter/tweet/advanced_search?${params}`, { headers: c.headers(key) })
      if (res.status !== 429 || attempt === 5) break
      const retryAfter = Number(res.headers.get("retry-after"))
      await sleep(retryAfter > 0 ? retryAfter * 1000 : 1000 * 2 ** attempt) // back off, then retry
    }
    if (!res.ok) throw new Error(`${provider} ${res.status}`)
    const body = await res.json()
    for (const t of body.tweets ?? []) yield t
    if (!c.hasMore(body) || !body.next_cursor) return
    cursor = body.next_cursor
  }
}

Switching checklist

1. List the endpoints you call and how often. Price the list with the tables above; most bills are two or three endpoints.
2. Measure your real items per call for a day. Monitoring checks, profile lookups and tweet-by-ID requests are where TwitterAPI.io is lower.
3. For TwitterAPI.io, replace timeline polling with from:handle since_id: searches where you only need new posts.
4. Swap the base URL and auth header, and map queryType/product and has_next_page/has_more.
5. Diff the tweet objects for each endpoint you use (field names, nested user object, media) and adjust your parser.
6. Check the rate limit against your backfill, not your normal load; on TwitterAPI.io make a first payment before load testing (unpaid accounts are limited to 0.2 requests a second).
7. Run both in parallel for a few days on the free credits and compare bills and row counts before cutting over.

Price your own workload

The calculator from our Twitter API price comparison, with TwitterAPIs highlighted. Enter how many searches you run, how many tweets they usually return and the request rate you need. For every endpoint price and how the plan credits are computed, see pricing.

If most of your requests return full pages of tweets (bulk exports, full timelines), compare the per-page price for your volume; on the Business plan a 20-tweet page costs $0.0016 after 12 monthly payments ($0.002 in the first month).

What TwitterAPIs' comparison page says about us, checked

TwitterAPIs publishes its own comparison with TwitterAPI.io (twitterapis.com/twitterapis-vs-twitterapi-io). Several of its statements about us were right when written and have since changed, or leave out part of the picture. Here they are against our current pricing and docs.

Against the official X API

Both services exist because of what the official API costs. X now bills per resource read with no subscriptions: according to its pricing documentation, $0.005 per post read, $0.010 per user read and $0.010 per follower or following read; creating a post costs $0.015, or $0.20 if it contains a URL. Pay-per-use is capped at 3 million post reads per monthly billing cycle, above which you need an Enterprise agreement. New accounts get $20 of credits when they save a first eligible card, plus a match of the first auto-recharge up to $50.

The official API still makes sense when you need a contract with X, posting through X's own consent screen, or data that only an authenticated first-party app can read. For reading public posts, TwitterAPI.io costs about 1/33 of the official price; for single profile lookups the official price is $0.010 against $0.00018 here. See TwitterAPI.io vs the official X API for the full comparison.

Quick decision guide