Twitter API Cost per 1,000 Calls: TwitterAPIs vs Twitter API v2 vs RapidAPI vs Apify, Real Benchmark (2026)

You are reading the normalized cost-per-1,000-calls benchmark. Looking for the providers ranked one at a time with hidden-fee callouts? Head to the cheapest Twitter API ranking. Want the 12-month spend projection for your own traffic rather than a head-to-head? Use the Twitter API cost math guide.

Pulling the same 100,000 tweets in a month costs $4 on one provider and $500 on another. That is not a rounding error or a negotiated discount; it is the published list pricing in 2026, and the gap is what this benchmark exists to make legible. Across the five paths developers actually choose between, the cost to read a Twitter feed spans more than 100x, and almost nobody states it in the one unit a finance team can act on.

So that is the unit this page uses everywhere: cost per 1,000 tweet reads. On that axis, TwitterAPIs reads at $0.04, twitterapi.io at $0.15, the Apify pay-per-result actor at $0.18, and the official X API v2 at $5.00 for standard reads ($1.00 if the data is your own account). RapidAPI is a marketplace rather than a single price, and its Twitter listings cluster between $0.10 and $0.50. Every number is normalized to the same denominator instead of buried inside a credit system, a tier table, or a per-resource charge that hides the real per-tweet cost.

TL;DR: Measured against list pricing pulled on 2026-06-11, one thousand tweet reads cost $0.04 on TwitterAPIs, $0.15 on twitterapi.io, $0.18 on the Apify actor, and $5.00 on the official X API v2 standard rate, dropping to $1.00 for owned reads. RapidAPI Twitter listings span a verified $0.10 to $0.50 band. The TwitterAPIs figure is a first-party measured rate; every competitor figure is that vendor's own published price.

There is one ground rule for the data below, and it is worth stating before any number appears. The TwitterAPIs cost and throughput come from observed first-party usage. Every competitor figure is that provider's public list price, each carrying its source link and its retrieval date. We do not publish competitor latency, because we did not measure competitor latency, and a benchmark loses its value the moment it starts inventing the numbers it cannot verify. The aim is something you can re-derive line by line, not a sales sheet wearing a lab coat.

Each published rate here was read on June 11, 2026, straight from the vendor's pricing surface: the official X API pricing page for the X API v2 numbers, the twitterapi.io pricing page for its credit math, and both the Apify platform pricing and the pay-per-result Twitter scraper actor listing for the Apify rate. The April 2026 X API changes come from the official X Developer Community changelog. These rates drift, sometimes sharply, so each one is stamped with a date rather than treated as permanent.

Why per-1,000-reads is the only honest unit

Before the table, the unit needs defending, because the wrong unit is how most pricing comparisons mislead without lying. Cost per 1,000 tweet reads is simply what it costs to retrieve a thousand tweets on a given provider, collapsed onto one axis so vendors with completely different billing schemes can be lined up next to each other. It works as the budgeting unit because a real workload reduces to exactly this: a tweet count times a rate.

The wrinkle is that no two vendors agree on what counts as "a call." The official X API meters by resource, so one tweet read equals one $0.005 charge, full stop. A direct API such as TwitterAPIs meters by request, and a single request hands back a batch of roughly 20 tweets, which means the headline per-call price wildly overstates the real per-tweet cost. Compare the raw call prices and you compare nothing useful. Normalize both to cost per 1,000 tweet reads, the figure your invoice is actually denominated in, and the comparison becomes apples to apples.

The math is short enough to show rather than assert, so here it is, reproducible:

# Collapse each provider onto one axis: dollars per 1,000 tweet reads.
# TwitterAPIs is observed; the X API rows are published list pricing (2026-06-11).

RATE_CARD = {
    "TwitterAPIs":       {"call_price": 0.0008, "tweets_returned": 20},  # measured
    "X API v2 standard": {"call_price": 0.005,  "tweets_returned": 1},   # docs.x.com
    "X API v2 owned":    {"call_price": 0.001,  "tweets_returned": 1},   # docs.x.com
}

def dollars_per_1k(call_price, tweets_returned):
    return round((call_price / tweets_returned) * 1000, 4)

for vendor, terms in RATE_CARD.items():
    print(f"{vendor:<18} ${dollars_per_1k(**terms):.2f} / 1K reads")

# TwitterAPIs        $0.04 / 1K reads
# X API v2 standard  $5.00 / 1K reads
# X API v2 owned     $1.00 / 1K reads

The 20-tweets-per-call multiplier is the entire reason a $0.0008 call resolves to $0.04 per thousand reads instead of $1.60. It is also the reason a side-by-side of raw call prices is a trap: until you divide by the data each call actually delivers, you are comparing labels, not value.

The benchmark table

With the unit settled, the comparison is one table. Cost per 1,000 tweet reads is the column that maps onto a monthly bill, because read volume is the thing that grows as an app finds users.

Provider	Cost per 1,000 tweet reads	Free tier	Minimum spend	Pricing source
TwitterAPIs	$0.04 (measured)	$0.50 credit, about 625 calls	None	twitterapis.com/pricing
twitterapi.io	$0.15	None	None (pay as you go)	twitterapi.io/pricing
Apify (pay-per-result actor)	$0.18	$5 credit per month	None	apify.com/pricing
RapidAPI (marketplace listings)	$0.10 to $0.50 (varies)	Varies by listing	Varies by listing	RapidAPI listing pages
X API v2 (owned reads)	$1.00	None	None	docs.x.com pricing
X API v2 (standard reads)	$5.00	None	None	docs.x.com pricing

Each competitor row is published list pricing read on 2026-06-11. The TwitterAPIs row is measured from real usage: a standard call is priced at $0.0008 and returns about 20 tweets, and those two facts together produce the $0.04 per 1,000 figure.

Read the table top to bottom and the spread is the story. TwitterAPIs at $0.04 undercuts the X API standard read rate of $5.00 by roughly 100x, comes in about 3.75x below twitterapi.io at $0.15, and roughly 4.5x below the Apify actor at $0.18. The one row that breaks the pattern is owned reads: the official $1.00 per 1,000 owned rate pulls the first-party API into the same neighborhood as the third-party field, which turns out to matter for a specific workload covered further down.

If you would rather see these rates compounded across twelve months at your own volume, the Twitter API cost math guide projects per-workload spend over time. Treat this benchmark as the head-to-head snapshot and that guide as the trajectory.

The measured month versus the official month, made concrete

Percentages blur; a monthly invoice does not. So pin the benchmark to a real workload: 100,000 tweet reads in a month, the kind of volume a mid-size monitoring or research pipeline burns through. Because all five pricing models scale linearly with read count, this single volume maps cleanly onto every published rate.

Provider	100,000 reads per month	Source
TwitterAPIs	$4 (measured)	twitterapis.com/pricing
twitterapi.io	$15	twitterapi.io/pricing
Apify (actor)	$18	apify.com/pricing
X API v2 (owned reads)	$100	docs.x.com pricing
X API v2 (standard reads)	$500	docs.x.com pricing

There it is in dollars: $4 versus $500 for the identical 100,000 reads, the 125x gap restated as a line item rather than a ratio. And since none of these rates bend with volume, the dollar distance only stretches as the workload grows.

TwitterAPIs: the measured baseline

TwitterAPIs is a pay-per-call Twitter and X data API. A standard call is $0.0008 and returns roughly 20 tweets, which is what lands it at a measured $0.04 per 1,000 reads. There is no X developer account to clear and no subscription to carry, and the credits you buy do not expire. Its surface spans 48 endpoints, 29 of them reads (tweets, threads, timelines, user lookups, search, followers) and 14 writes, which keeps it out of the read-only-scraper bucket competitors sometimes get filed under.

This is the lone provider in the benchmark whose performance is observed rather than copied off a pricing page, for the simple reason that its usage is directly visible here. The $0.04 figure is built from actual call behavior: the $0.0008 call price is published on the TwitterAPIs pricing page, and the roughly 20-tweets-per-call batch size is the measured average that converts that call price into a per-1,000-reads rate.

A bare read call is short. The whole auth story is one Bearer header, which is usually the only thing that changes when you switch off another provider:

# TwitterAPIs: one search call returns a batch of ~20 tweets for $0.0008.
curl -s "https://api.twitterapis.com/v1/tweets/search?query=twitter%20api%20cost&limit=20" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

The same request from Python, where most analytics and data teams begin:

import os
import requests

API_KEY = os.environ["TWITTERAPIS_KEY"]

response = requests.get(
    "https://api.twitterapis.com/v1/tweets/search",
    params={"query": "twitter api cost", "limit": 20},
    headers={"Authorization": f"Bearer {API_KEY}"},
    timeout=30,
)
response.raise_for_status()
batch = response.json().get("data", [])
print(f"pulled {len(batch)} tweets for a single $0.0008 call")

Writes work a little differently and are worth a sentence, because it is where "third-party API" stops meaning "scraper." The 12 write actions, favorite and unfavorite, retweet and unretweet, bookmark and unbookmark, follow and unfollow, delete, tweet creation, media upload, and DM send, are billed at $0.0008 a call for the simple writes and $0.0016 for tweet creation and DM send, and run with a per-request auth_token and ct0 you supply yourself; those credentials are never stored server-side. For a deeper tour of the read endpoints, the Python Twitter API tutorial covers search, timelines, and user lookups end to end, and the TwitterAPIs best practices guide covers production concerns like pagination and retry. If your question is features rather than price, the Twitter API v2 vs TwitterAPIs breakdown is the direct comparison.

Why does a direct API like this exist at all? It traces a story most developers recognize: a scraper or an actor is perfectly fine until volume climbs, and then the bill starts compounding faster than the project did. The person who built TwitterAPIs narrated exactly that arc in a public launch thread.

Twitter's Pricing is Ridiculous! from r/SaaS

Where the official X API still earns its place

The official X API v2 is the anchor everyone else is priced against, and on most read workloads it is the most expensive option in the table by a wide margin. It is X's own first-party API, sold pay-per-use, with no subscription and no free read tier for new developers. A standard tweet read is $0.005, so $5.00 per 1,000, while an owned-account read is $0.001, or $1.00 per 1,000, per the pricing read on 2026-06-11. The per-operation split matters, because writes and profile lookups carry their own rates that have nothing to do with the read price.

A standard authenticated read needs an OAuth 2.0 bearer token minted from a registered X developer app:

# Official X API v2: recent search, each tweet read billed as a separate $0.005 charge.
curl -s "https://api.x.com/2/tweets/search/recent?query=twitter%20api%20cost&max_results=20" \
  -H "Authorization: Bearer $X_BEARER_TOKEN"

Because every tweet is its own charge, the cost is brutal at scale and there is no batch discount to soften it the way a per-call API gives you:

# Official X API standard reads scale 1:1 with tweets fetched.
STANDARD_READ = 0.005  # docs.x.com pricing, 2026-06-11

def official_read_bill(monthly_tweets):
    return round(monthly_tweets * STANDARD_READ, 2)

for volume in (1_000, 10_000, 100_000, 1_000_000):
    print(f"{volume:>9,} reads/mo -> ${official_read_bill(volume):,.2f}")

#     1,000 reads/mo -> $5.00
#    10,000 reads/mo -> $50.00
#   100,000 reads/mo -> $500.00
# 1,000,000 reads/mo -> $5,000.00

Nothing free cushions the on-ramp. For the backstory on how free access vanished and what is left, the is the Twitter API free guide walks through the February 2023 removal and the current state. Price aside, the official API also imposes rate limits that the Twitter API rate limit guide covers in depth.

The sticker shock that sends people hunting for alternatives is all over public forums. One developer ran the new pay-per-use model in production and posted the receipt, roughly $1 per 200 posts, which lines up exactly with the $5.00-per-1,000 standard read rate.

Reliable way to scrape X (Twitter) Search? from r/webscraping

Developers weighing what they pay against what they get tend to be blunt about it, and that cost-shock is what sends most of them comparing providers in the first place. One sums it up as pricing that is hard to justify for ordinary use:

https://x.com/mreiffy/status/2059878453638209629

The April 2026 reprice, and the one workload it flips

There is exactly one scenario where the official API stops being the expensive option, and the April 2026 change created it. On April 16, 2026, X announced adjustments effective April 20: owned reads fell to $0.001 per resource, post writes rose to $0.015, and any post carrying a URL stayed pinned at $0.20. The owned-read cut is the headline for cost.

For one narrow class of work, that cut is genuinely meaningful. If an app only ever reads its own timeline, its own follower list, or its own DMs, the official API at $1.00 per 1,000 owned reads is now in the same order of magnitude as the third-party field, and it comes with first-party compliance attached. Step outside owned data, into search, competitor monitoring, sentiment on accounts you do not control, or third-party enrichment, and the $5.00 standard rate snaps back, leaving direct APIs far cheaper. The full timeline and developer reaction live in the X API pricing change 2026 analysis.

A widely-shared thread from a product analyst breaks down the 2023 tier model and puts the broader cost picture plainly, pointing out that for ordinary usage the new pay-per-use math can run past the old $200 Basic plan it replaced:

https://x.com/aakashgupta/status/2019991413442900046

The writes moved the opposite way. At $0.015 per post, and $0.20 once a URL is involved, anything that posts at volume got materially pricier. One factuality note carries weight here: these are the official published numbers as of 2026-06-11, and X has repriced twice inside roughly a year, so re-read the docs.x.com pricing page before you lock a budget against them.

The three third-party paths, ranked by what trips them up

Below the official API sit three popular alternatives. Their rates are close enough that the deciding factor is rarely the headline number; it is the structural thing about each that catches a workload off guard.

twitterapi.io: the mid-tier rate with no monthly floor

twitterapi.io is a credit-billed third-party Twitter data API, with tweet reads listed at $0.15 per 1,000 tweets per its published pricing read on 2026-06-11. It slots between the official API and the cheapest direct APIs. The rate decodes from 15 credits per tweet against $1 buying 100,000 credits, which works out to $0.15 per 1,000. Profile reads cost a bit more, around $0.18 per 1,000. There is no free credit, but there is also no monthly minimum, so it behaves as pure pay-as-you-go at a mid-tier price.

# twitterapi.io decodes to 15 credits per tweet, where $1 = 100,000 credits.
CREDITS_PER_DOLLAR = 100_000  # twitterapi.io/pricing, 2026-06-11
CREDITS_PER_TWEET = 15        # published

rate_per_1k = (CREDITS_PER_TWEET * 1_000) / CREDITS_PER_DOLLAR
print(f"twitterapi.io: ${rate_per_1k:.2f} per 1,000 tweet reads")
# twitterapi.io: $0.15 per 1,000 tweet reads

As a middle path it is reasonable: about 33x under the official API on reads, about 3.75x over the cheapest direct APIs. If you are on it already and considering a move, the migrate from twitterapi.io to TwitterAPIs guide covers the swap, which is mostly a base-URL and an auth-header change.

Apify: cheap per result, until the credits expire

Apify is a scraping platform, and its pay-per-result Twitter scraper actor lists $0.18 per 1,000 tweets per the actor listing and platform pricing read on 2026-06-11. It also sells monthly plans, $29 Starter and $199 Scale, whose credits reset and expire every month.

The $0.18 actor rate is the clean number, and at roughly 28x under the official standard read rate it looks great on its own. The problem is the subscription wrapped around it. Apify credits expire at month end and never carry over, so a workload that spikes can torch a full monthly allotment in one oversized run.

# Apify: a flat per-result rate sitting on top of an expiring monthly credit pool.
ACTOR_RATE_PER_1K = 0.18  # apify.com pay-per-result actor, 2026-06-11
STARTER_CREDIT = 29.0     # monthly, expires at month end

def apify_run_cost(tweets):
    return round((tweets / 1_000) * ACTOR_RATE_PER_1K, 2)

# One 200K-tweet run on the actor:
print("200K-tweet run:", f"${apify_run_cost(200_000)}")  # $36.00
# On a $29 expiring-credit plan, a single large run can drain the whole month.

Developers hit this in the wild. A public r/n8n thread documents one Apify run swallowing an entire monthly credit on a paid plan, the exact surprise that drives high-volume teams toward a pay-per-call model with no pool to drain. For a deeper cost-and-reliability head-to-head, the Apify Twitter scraper vs TwitterAPIs comparison goes further, and the best Twitter API for scraping guide sets Apify against browser and library approaches.

An automation walkthrough shows the cheaper-than-official pattern inside a real workflow, with Apify handling the scrape step:

https://www.youtube.com/watch?v=otK0ILpn4GQ

RapidAPI: a storefront, not a price

RapidAPI is a marketplace hosting many independent Twitter listings from different publishers, so there is no single RapidAPI Twitter rate to quote. Verified listings tend to land between $0.10 and $0.50 per 1,000 calls depending on the publisher and the plan tier.

This is the one entry in the benchmark that refuses a point estimate, and inventing a fake-precise figure would be dishonest. The marketplace folds its own margin into every sticker, so a publisher who lists $0.16 per 1,000 on their own site often shows $0.20 on RapidAPI for the identical endpoint. Translated across the common Twitter listings, per-call costs span an estimated $0.10 to $0.50 per 1,000, a verified range rather than a single figure.

# RapidAPI Twitter listings: a verified band, never one fixed price.
# Price moves with publisher and plan tier; do not hardcode a single value.
RAPIDAPI_BAND_PER_1K = (0.10, 0.50)  # verified across common listings

low, high = RAPIDAPI_BAND_PER_1K
print(f"RapidAPI Twitter listings: ${low:.2f} to ${high:.2f} per 1,000 calls")
# Always size against the specific listing's live plan page, not the band.

The real tradeoff is reliability rather than price. You do not get to pick which listing is well maintained this quarter, and one that is excellent today can rot once the publisher loses interest or gets acquired. The RapidAPI Twitter alternative guide covers the marketplace mechanics, the outage patterns, and the one-hour path to a direct API in full.

Writes: the asymmetry that quietly sets your bill

Most cost comparisons silently assume read traffic, since reading public tweets is the dominant job for data, analytics, and monitoring. But the April 2026 restructuring loaded cost onto the write side, so a project that posts at volume will find the read benchmark above understates its real bill. The write rates deserve to be pulled out so the two halves never get blended.

On the official X API, a plain post write is $0.015 and a post with any URL is $0.20, per the official changelog. The $0.20 figure is the one that ambushes people, because a single link-bearing post costs more than thirteen plain ones. A newsletter relay or an RSS-to-X bot that always carries a URL pays the link rate on every post it makes. Ten link-posts a day is an estimated $60 a month; a hundred a day is roughly $600, for output that cost a handful of dollars under the old flat rate.

That asymmetry is the planning lesson. A read pipeline and a posting bot are two different products with two different cost curves, and stapling them to one expensive tier is precisely what made April sting. The cheaper architecture separates them: route reads through a per-call read API at $0.04 per 1,000, keep writes on whichever route the platform forces, and audit how many of those posts genuinely need an inline link. The X API pricing change analysis covers the write-side workarounds, including dropping the link into a reply to sidestep the $0.20 band.

This benchmark deliberately holds the comparison to reads, because reads are where third-party providers open the widest gap and where most projects spend most of their request budget. If your workload tilts toward writes, treat the read table as one input and price the write actions separately at the rates above.

Free credits exist to evaluate, not to run on

A standing question under any cost comparison is whether you can start for free. The short answer: the official X API offers no free read tier to new developers, while a few third-party APIs seed a small credit so you can kick the tires before spending.

The official pay-per-use model wants credits bought upfront, with no standing free monthly read allowance, per the official pricing page. The leftover free Basic tier is write-limited with a tiny monthly post cap and effectively no read access, so it is not a home for reading public data at any real volume. On the third-party side, TwitterAPIs drops $0.50 of credit into a new account, about 625 standard calls and roughly 12,500 tweets, with no card required, and the Apify free plan carries $5 of monthly platform credit. twitterapi.io seeds no free credit but imposes no monthly minimum, so it reads as pure pay-as-you-go.

The honest read is that these allowances are for evaluation, not for running a workload for free. They are enough to confirm a key works and to eyeball the response shape, which is exactly the right way to vet a provider before committing budget. Size your real spend against the per-1,000 table, not the trial credit, because the trial credit evaporates fast at production volume.

How this differs from the single-vendor pricing guides

Most of the well-ranked Twitter API pricing guides explain one provider's billing thoroughly and stop there, which is genuinely useful but leaves the cross-provider question hanging. It is worth naming what they cover so you know where to go for the parts this benchmark does not re-derive.

The Blotato 2026 pricing guide is a careful tour of the official X API tiers, the legacy Basic and Pro plans included, and it flags the $0.20 per-link-post detail that ambushes automated publishers. The PostProxy X API pricing breakdown concentrates on read-heavy cost math under pay-per-use, a good companion to the worked example above. The Zernio pricing explainer works the $0.005-per-request read math from a competing alternative's angle. What none of them do is line TwitterAPIs, twitterapi.io, Apify, and the official API up in one normalized cost-per-1,000-reads table, which is the gap this post fills.

The gap exists because most of those guides are published by a single provider with a stake in how the comparison is framed. A benchmark that names one measured first-party rate and pairs it with published list pricing for the rest, each carrying a dated source link, is auditable in a way a single-vendor explainer cannot be. The point is not that the others are wrong; it is that they answer a narrower question, how does this one provider bill, rather than which provider is cheapest for the workload in front of you.

For background on what the X API actually is and where the credit system fits, the official About the X API page is the canonical reference. Read it alongside the pricing page, since the credit mechanics and the per-action rates are documented separately and the bill leans on both.

Match the provider to the workload, not the brand

The cheapest provider is a function of what you read and why, so there is no single winner. The owned-read rate, the third-party read rate, and the compliance-bound case each crown a different option.

The call splits into three clean branches:

• Reading your own account data (timeline, followers, your own DMs): the official X API owned-read rate at $1.00 per 1,000 is competitive and hands you first-party compliance. The follower export guide walks this workload.
• High-volume third-party reads (search, monitoring, enrichment): a direct API like TwitterAPIs at $0.04 per 1,000 is the cheapest predictable pay-as-you-go route. The scrape tweets guide and the sentiment analysis guide cover the common read-heavy cases.
• OAuth or compliance-bound work: the official X API v2 at $5.00 per 1,000 standard reads is the right answer when a contract or a user-delegated OAuth flow is non-negotiable, cost notwithstanding.

If the workload leans write-heavy instead, the math shifts again because of the $0.015 per post and $0.20 per post-with-URL rates. The advanced search operators reference covers the query-construction side that keeps read costs down, and before you commit to anyone, the how to get a Twitter API key guide covers the setup friction the official portal adds and that direct APIs skip.

A codedamn walkthrough on cutting a large Twitter API bill makes the same point from the practitioner's chair: the biggest savings come from picking the right provider for the workload before you optimize anything inside it.

https://www.youtube.com/watch?v=uCnMxkT1GfQ

Plan for the price to move, because it will

A cost benchmark is a snapshot, and the most important caveat is that the snapshot expires. The official X API has repriced twice in roughly a year, which is exactly why every comparison here carries a retrieval date. Budgeting against a number you read once is how a project gets ambushed by an invoice.

None of this is unique to X, or new for X. Twitter first ended free API access in February 2023, then announced the Free, Basic, and Enterprise tier structure that priced out a wave of independent developers, before the April 2026 shift to pay-per-use that Social Media Today covered as a usage-based access charge. The clearest cross-platform precedent is Reddit's 2023 API reprice, reported widely at the time, which killed a generation of third-party clients almost overnight once the ecosystem was big enough to monetize. The pattern repeats: cheap or free access to grow an ecosystem, then a price that harvests value once developers are locked in. The dollar figures differ each time; the cycle is predictable enough to design around.

The insulation is architectural, not contractual. Put a thin internal interface in front of your data access so the provider underneath is a config value rather than a dependency stitched through the codebase. Call a platform API directly in fifty places and a price change is a rewrite; call your own wrapper and it is a one-module edit. Pair that with knowing which workloads are reads versus writes, keep a tested fallback provider on the shelf, and a reprice becomes an annoyance instead of an outage. The numbers will drift. Dated sourcing and loose coupling are what keep the drift from hurting.

The second insulation is right-sizing the unit you budget in. Teams that think in monthly subscription tiers get blindsided when a bursty run blows through an expiring credit pool, the Apify failure mode developers keep reporting. Teams that think in cost per 1,000 reads, with no monthly floor, can size by budget and let usage chase demand. That is the deeper reason the per-call model tends to win for unpredictable read traffic: it removes the mismatch between a fixed monthly commitment and a variable real request count.

The verdict

For read-heavy third-party Twitter work, the cheapest Twitter API in 2026 at pay-as-you-go list pricing is a direct API: TwitterAPIs at a measured $0.04 per 1,000 reads, about 100x under the official X API standard rate of $5.00. twitterapi.io at $0.15 and the Apify actor at $0.18 are the mid-tier direct options, and RapidAPI marketplace listings land in a verified $0.10 to $0.50 band that swings by listing.

The official X API holds its ground in two cases only: owned-account reads, where the $0.001 rate is now competitive, and OAuth or compliance-bound work, where a contract makes the price secondary. Everywhere else the benchmark is one-sided, and the savings only compound as volume grows. Match the provider to the workload, and re-read the published pricing pages, because the official rate has moved twice in roughly a year.

To run your own numbers, drop your projected mix into the cost calculator, and check the live rate card on the pricing page.