TwitterAPI.io vs GetXAPI: price per data type, plans, 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 over a 15-day window, grouped them into workloads, and priced the average request in each on both services, with GetXAPI at its pay-as-you-go rate. The table shows the workloads where TwitterAPI.io is lower, and the whole-mix row covers every request.

The biggest workload is monitoring: 38% of all requests are checks that find nothing new, and those cost $0.00015 here against $0.001. Profile requests average about $0.00038 and tweet details about $0.00039 a request at pay-as-you-go prices, against GetXAPI's $0.001.

GetXAPI's monthly plans bring its price to $0.00033–$0.0005 per call by card. A monitoring check here, at $0.00015, still costs less than on any of them, and on our Business plan profiles and tweet details ($0.0002 and $0.0002 a request) are below every GetXAPI plan as well.

How each one bills

Every bill on either service is number of requests × price per request. What differs is how the price per request is set, and on GetXAPI, whether you prepay for a plan.

GetXAPI prices each endpoint per call. Its pricing page (getxapi.com/pricing) lists 43 endpoints at $0.001 (standard reads and light writes), 6 at $0.002 (posting, DMs, notifications), the complete timeline at $0.003, 9 at $0.005 (threads, articles, account recovery) and 2 at $0.010 (article creation and login), plus Spaces downloads from $0.05. A search that returns 20 tweets and one that returns none cost the same $0.001. Top-ups start at $10 and never expire.

GetXAPI also sells optional monthly plans that are credits at a discount: Pro $15 for $30 of credits (about 30,000 standard calls), Growth $49 for $120 (about 120,000) and Scale $99 for $300 (about 300,000). Paid by card, that is $0.0005, $0.00041 and $0.00033 per standard call. Paying in crypto adds $10, $20 or $50 of credits, which brings the rates to $0.000375, $0.00035 and $0.000283; this page uses the card prices. Plan credits are spent first, roll over while the plan is active and lapse if it ends. A one-time $5 starter pack gives $4.50 of credits for 30 days.

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: search, replies, mentions and user timelines are all billed per tweet returned. The formula is:

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

Against GetXAPI's pay-as-you-go $0.001, a request here costs less as long as it returns 6 tweets or fewer. Against its card plans, a search that returns nothing ($0.00015), one tweet ($0.00015) or two ($0.0003) costs less here than on any of them.

Our subscriptions stretch that further. They 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, assuming every extra credit is used before it expires. On Business a request here stays below GetXAPI pay-as-you-go up to about 12.7 tweets.

Price per data type

A single “per 1,000 tweets” number hides most of the difference, because the price of a request depends on what it returns, and GetXAPI's price depends on whether you are on a plan. This table prices the kinds of data where TwitterAPI.io is lower, the way you would actually fetch them. Green marks the lower price on that row.

Items per page: both return up to about 20 tweets per search page and 20 verified followers per page. GetXAPI plan prices are its per-call price times what a plan charges per dollar of credits paid by card, and assume you use the credits. TwitterAPI.io prices are from our pricing page; GetXAPI prices from its pricing page (getxapi.com/pricing) and API reference (docs.getxapi.com/llms.txt), checked in 2026.

What a month costs: six workloads

Rate cards only matter once they meet a workload. These are six common jobs, each costed on both services with the arithmetic shown, so you can swap in your own numbers. For GetXAPI we take the lower of pay-as-you-go and the best-fitting plan, with any calls above the plan paid from top-up credits at $0.001 (top-ups are bought in $10 lots and never expire). Plan prices are card prices.

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

GetXAPIPro $15 (30,000 calls) + 13,200 × $0.001 = $28.20 (pay-as-you-go $43.20)

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

144,000 searches, about 1 new tweet each

TwitterAPI.io144,000 × $0.00015 = $21.60

GetXAPIGrowth $49 (120,000 calls) + 24,000 × $0.001 = $73.00 (a search is one call)

Enrich 100,000 profiles

by user ID; batches of 100+ here, one per call there

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

GetXAPIGrowth $49.00 (120,000 calls; pay-as-you-go $100.00)

Hydrate 100,000 tweets by ID

IDs you already have (from a dataset or a stream)

TwitterAPI.io100,000 × $0.00015 = $15.00

GetXAPIGrowth $49.00 (one tweet per call; pay-as-you-go $100.00)

100,000 verified followers

20 per page on both

TwitterAPI.io5,000 pages × $0.00015 = $0.75

GetXAPI5,000 calls × $0.001 = $5.00

Real-time feed of 10 fixed accounts

push delivery, monthly plan

TwitterAPI.io$29 + 4 × $5 = $49.00

GetXAPIGrowth monitoring (20 accounts, 2-second tier): $59.00

Jobs that repeat a search and usually find little cost about 3.6 times less on TwitterAPI.io even against a GetXAPI plan, because an empty check is $0.00015; watching 200 accounts for new posts costs about 3.4 times less. Lookups by ID (profiles, tweets) and verified followers cost far less here, because we return many items per request or price the page low.

GetXAPI plan figures are card prices. Paying in crypto adds $10 / $20 / $50 of credits to each plan; then the keyword alert is $18.20, the 200-account job $53.00 and the profile and tweet jobs $49.00 each on GetXAPI. No winner changes.

Pay-as-you-go here against a GetXAPI plan

The question most buyers actually have is whether a prepaid GetXAPI plan changes the picture. For alerting and monitoring it does not. An empty check is $0.00015 here against at least $0.00033 per call on a card plan ($0.00028 in crypto), so for workloads where most checks find nothing, no GetXAPI plan catches up with pay-as-you-go here.

Uneven volume favours pay-as-you-go too. A plan only reaches its per-call price if you spend its credits. GetXAPI's plan credits roll over while you stay subscribed, but they lapse when the plan ends, and a month with half the usual volume costs the same $15, $49 or $99. Pay-as-you-go here has no monthly fee and no minimum spend, and credits you buy never expire.

Our own subscriptions ($29 to $1,499 a month) work differently: they add 8–50% extra credits in the first month plus a monthly credit return, and they raise the rate limit (50 requests a second on Scale, 500 on Business). Counting the first-month bonus and 12 monthly returns, $1 buys 1.22× the credits on Builder ($99) and 1.9× on Business, which brings an empty check to $0.000079 on Business.

Poll accounts for new posts at the minimum price

Most timeline polling is really asking “has this account posted anything new?”, and that question is cheaper to ask as a search. A query like from:nasa since_id:<last id> returns only the new tweets: $0.00015 when nothing is new, $0.0003 for two. On GetXAPI the same search is a full $0.001 call ($0.00033–$0.0005 on a card plan), so checks that return one or two new tweets cost less here than on any GetXAPI card plan, and up to 6 new tweets cost less here than GetXAPI pay-as-you-go.

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

One caveat: 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. For sub-second delivery, use Twitter Stream or filter rules instead (below).

Features and limits

GetXAPI figures from its pricing (getxapi.com/pricing), rate-limit (getxapi.com/twitter-api-rate-limits), MCP (getxapi.com/mcp) and webhook (getxapi.com/twitter-webhook-api) pages and its API reference (docs.getxapi.com/llms.txt); TwitterAPI.io from our pricing, rate limits, Twitter Stream and MCP server pages. Checked in 2026.

Rate limits in practice

GetXAPI's rate-limit page (getxapi.com/twitter-api-rate-limits) says it has no per-endpoint daily or 15-minute windows, and that general service throttling still applies under sustained concurrency. It does not say at what rate, so you find the ceiling by testing. TwitterAPI.io publishes one number per account: 0.2 requests per second before the first payment, 20 after it, 50 on the Scale plan, 500 on Business and up to 1,000 on request, with a 429 and a Retry-After header when you go over. Your normal load rarely touches either ceiling. Backfills do: at 20 requests a second you can fetch about 1.7 million search pages a day. Write your client to handle 429 on both; the adapter below does.

Endpoint coverage

Most read endpoints exist on both: advanced search, replies, retweeters, mentions, user search, profiles, timelines, followers and followings, verified followers, list members, community info, Spaces metadata, trends and articles. These are only on TwitterAPI.io:

• Quote tweets (/twitter/tweet/quotes)
• Bulk tweets by ID (/twitter/tweets) and bulk profiles (/twitter/user/batch_info_by_ids)
• Follower IDs only, up to 5,000 per page
• List tweets and list followers; list member add and remove
• Community members, moderators and tweets; search across all communities
• Keyword filter rules pushed by webhook or WebSocket

Real-time delivery

Both can push new tweets instead of making you poll, but they push different things. GetXAPI's monitoring (docs.getxapi.com/docs/monitoring/overview) follows accounts: you register an account and a webhook, and every new tweet arrives as a signed POST, about 15 seconds after posting on the standard tier and about 2 seconds on the fast tier, with retries for roughly 21 minutes. It is billed as a flat monthly plan that does not touch your API credits, and it has no keyword rules. TwitterAPI.io offers both: Twitter Stream for a fixed account list, and keyword filter rules that run on our side and deliver matches by webhook or WebSocket, billed like polling the search yourself.

Because we add accounts one at a time ($5, $4 or $3 each depending on the plan) and GetXAPI moves you up a whole plan, a feed of 7–11, 21–29 or 51–83 accounts costs less here. Above 150 accounts, GetXAPI publishes no price; Twitter Stream lists a 500-account plan.

AI agents and MCP

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

The same request on both

The read endpoints share the /twitter/... path layout and nearly the same tweet fields (id, text, createdAt, likeCount, retweetCount, author.userName), so a search is the same request with a different host, header and parameter names:

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

# GetXAPI
curl -H "Authorization: Bearer $GETXAPI_KEY" \
  "https://api.getxapi.com/twitter/tweet/advanced_search?q=from%3Anasa&product=Latest"

GetXAPI request and response fields from its advanced search reference (docs.getxapi.com/docs/tweets/advanced-search) and API index (docs.getxapi.com/llms.txt). 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 differences in one place. This TypeScript generator pages through a search on either service and backs off and retries on 429, reading Retry-After when it is there:

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

const CONFIG = {
  "twitterapi.io": {
    base: "https://api.twitterapi.io",
    headers: (key: string) => ({ "X-API-Key": key }),
    params: (query: string) => ({ query, queryType: "Latest" }),
    hasMore: (body: any) => Boolean(body.has_next_page),
  },
  getxapi: {
    base: "https://api.getxapi.com",
    headers: (key: string) => ({ Authorization: `Bearer ${key}` }),
    params: (query: string) => ({ q: query, product: "Latest" }),
    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(c.params(query))
    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
      // Retry-After header first, then a retry_after body field, then exponential backoff
      let wait = Number(res.headers.get("retry-after"))
      if (!(wait > 0)) wait = Number((await res.json().catch(() => ({})))?.retry_after)
      await sleep(wait > 0 ? wait * 1000 : 1000 * 2 ** attempt)
    }
    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 table above; most bills are two or three endpoints.
2. Measure your real items per call for a day, and how many searches come back empty. Requests that return 6 tweets or fewer cost less on TwitterAPI.io than GetXAPI pay-as-you-go, and empty ones or those with one or two tweets cost less than on any GetXAPI card plan.
3. Decide plan or pay-as-you-go from a typical month, not your best one. Unused GetXAPI plan credits roll over while you stay subscribed but lapse when you cancel, so size the plan to a typical month.
4. For TwitterAPI.io, replace timeline polling with from:handle since_id: searches where you only need new posts, and replace one-by-one profile or tweet lookups with the bulk endpoints.
5. Swap the base URL and auth header, and map query/q, queryType/product and has_next_page/has_more.
6. Diff the tweet and user objects for each endpoint you use (nested author, media, entities) and adjust your parser.
7. Load-test with your real backfill. On TwitterAPI.io make a first payment first (unpaid accounts are limited to 0.2 requests a second); on GetXAPI, watch for 429 at your target concurrency, since no limit is published.
8. Run both in parallel for a few days on the free credits ($1 here if the account passes the invisible bot check (one per person and network); $0.10 there) and compare bills and row counts before cutting over.

Price your own workload

The calculator from our Twitter API price comparison, with GetXAPI highlighted. It picks the lower of GetXAPI pay-as-you-go and its best-fitting plan for the volume you enter. Enter how many searches you run, how many tweets they usually return and the request rate you need. For the full rate cards see Twitter API 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 GetXAPI says about us, checked

GetXAPI publishes a comparison with twitterapi.io (getxapi.com/getxapi-vs-twitterapi-io) and a migration guide (getxapi.com/blogs/migrate-from-twitterapi-io-to-getxapi). Several of their figures about us were accurate when written and have since changed; a few were not accurate. Here they are against our current pricing.

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 at pay-as-you-go prices. For profiles the gap depends on the endpoint: 1,000 user reads are $10 officially, $1.00 on GetXAPI, $0.18 one by one here and $0.01 in bulk. See TwitterAPI.io vs the official X API for the full comparison.

Quick decision guide