Best Twitter API Alternatives in 2026: 11 Providers Compared
Compare 11 Twitter API providers on pricing, free trials, credit expiry, rate limits, posting, DMs, and MCP, with the monthly cost of 2 million Posts on each.
This guide compares 11 ways to get Twitter data: TweetAPI, GetXAPI, twitterapi.io, TwexAPI, the official X API, Xquik, TwitterAPIs, Sorsa, SocialData, ScrapeBadger, and the Apify Tweet Scraper. The biggest difference is what they charge for:
- Per call: TweetAPI, GetXAPI, TwitterAPIs, and Sorsa charge for each request, whether a page returns one Post or twenty.
- Per returned item: twitterapi.io, Xquik, SocialData, TwexAPI, Apify, and the official X API charge for each Post or profile returned.
Per-call pricing favors dense pages such as search and timelines. Per-item pricing favors sparse results. For dense collection, TweetAPI is the lowest-cost option in this comparison: 2 million Posts in a month cost $17 on its Pro plan, against $49 or more with every other provider modeled here. When calls return only one or two results, per-item providers can cost less.
Price per call isn't the whole story. Also compare how much you have to pay up front, whether unused credit expires, how fast you can send requests, and whether you need posting, DMs, or an MCP server for AI agents.
See the cost at a glance, compare the payment models, check capabilities, see five workload scenarios, or run the calculator.
We checked every price on October 24, 2026. Prices in this market change often, so confirm them before you buy.
Disclosure: We run TweetAPI. This comparison uses each provider's published prices and claims; we didn't buy competitor plans or run benchmarks. The math assumes each provider returns comparable data, so test with your own workload. Where a checkout detail isn't public, we say so.
Disclaimer: TweetAPI is a third-party service. Not affiliated with X Corp.
Cost at a Glance: 2 Million Posts a Month
This is workload 3 below: 100,000 calls returning 20 Posts each in one billing cycle, with no trials, empty results, or retries.
| Provider | Monthly cost | Basis |
|---|---|---|
| TweetAPI | $17 | Pro plan |
| GetXAPI | $49 | Growth plan |
| TwitterAPIs | $80 | $0.0008 per call |
| TwexAPI | $99 | Pro plan |
| Sorsa | $199 | Pro plan |
| Xquik | $249 | Business plan plus a $50 top-up |
| twitterapi.io | $300 | Base rate; its $199 Pro plan plus a top-up may cost less |
| SocialData | $400 | $0.20 per 1,000 Posts |
| Apify Tweet Scraper | $800 | $0.40 per 1,000 Posts before discounts, on a paid Apify plan |
| Official X API | $10,000 | $0.005 per Post read |
Apify's figure covers the same 2 million Posts rather than the same calls, because it charges per Post and needs at least 50 per query. ScrapeBadger is not modeled because its per-endpoint credits are not on its pricing page. Sparse workloads change the order; see workload 2.
Quick Answer: Which Twitter API Alternative Is Best?
Shortlist by workload, then test the endpoints you actually need:
| Workload | Candidates to compare | What matters |
|---|---|---|
| Occasional page-based collection | TweetAPI PAYG, GetXAPI top-ups, TwitterAPIs | Minimum purchase, request weight, remaining credits, expiry |
| Steady monthly collection | TweetAPI plans/hybrid, GetXAPI subscriptions, TwexAPI subscriptions | Plan allowance, bonuses, rate limits |
| Sparse responses or long gaps between jobs | TweetAPI PAYG, twitterapi.io, Xquik, SocialData, GetXAPI top-ups, TwexAPI packs | Per-item versus per-call charges; credit expiry |
| Short bursts above a few requests per second | TweetAPI Giga or Tera (50–60 per second), twitterapi.io, Sorsa, or TwexAPI's larger packs | The rate limit your account actually gets |
| Posting, DMs, and reads with one key | TweetAPI, TwitterAPIs, GetXAPI, Xquik, twitterapi.io, TwexAPI | Which actions exist, what each write costs, and which credentials they need |
| Read-only data and verification checks | TweetAPI (follow checks), Sorsa, SocialData | Batch sizes, check endpoints, plan minimums |
| No-code scraping runs | Apify Tweet Scraper | Per-result price, per-query minimums, Apify plan limits |
| Official OAuth, archive, filtered stream, or direct procurement | Official X API | Official features and per-endpoint limits |
With TweetAPI's pay-as-you-go (PAYG) option, you don't need a monthly plan to start. It covers the same endpoints as the plans, but no third-party API replaces official X sign-in, the full archive, or the filtered stream.
Collecting data for a study? The guide for academic research covers research costs, tweet ID datasets and data quality.
Twitter API Alternatives Compared
| Provider | Billing unit | Entry payment | Free trial | Paid credit expiry |
|---|---|---|---|---|
| TweetAPI | Per call: 1 unit for most calls | $5/10,000 prepaid units; plans from $17/month | 100 one-time units, no card | PAYG: 365 days, extendable by later top-ups; plans: billing-cycle allowance |
| GetXAPI | Per call: $0.001 for most reads | $10 top-ups; $5 one-time Starter; plans from $15/month | $0.10 | Top-ups never expire; plan credits roll over while the plan is active |
| twitterapi.io | Per item: $0.15/1,000 Posts, 15-credit minimum per call | Top-ups; plans from $29/month | Up to $1, expires after 31 days | Paid credits never expire; bonus credits expire after 31 days |
| TwexAPI | Per item: 5 credits per typical read | $20 Mini; plans from $50/month; one-time packs from $100 | 20,000 credits for 7 days | Mini: one day; subscriptions: monthly refresh; Standard and larger packs: no expiry |
| Official X API | Per item: $0.005 per Post read | Prepaid credits in the Developer Console | None; $20 of credit after your first purchase | Check the Developer Console terms |
| Xquik | Per item: $0.00015 per delivered result | $10 top-ups; plans from $20/month | None | Top-ups never expire; plan credits carry over |
| TwitterAPIs | Per call: $0.0008 for reads | Top-ups from $10 | $0.50 | Credits never expire |
| Sorsa | Per call: one request from a monthly plan | $49/month for 10,000 requests | 100 requests that never expire | Monthly plan allowance; optional prepaid overage |
| SocialData | Per item: $0.20/1,000 Posts or profiles | Prepaid balance, any amount | None; demo on request | Balance does not expire |
| ScrapeBadger | Credits per request; $0.15/1,000 credits on PAYG | $10 PAYG; plans from $49/month | 1,000 credits | PAYG credits do not expire |
| Apify Tweet Scraper | Per item: from $0.40/1,000 Posts | An Apify plan that allows API use | Apify free plan: 5 runs a month, 10 items each, no API | Follows Apify plan billing |
RPM is requests per minute and QPS is requests per second: 60 RPM averages one request per second, not bursts of 60. Buying more credits doesn't always raise your rate limit.
Capability Checklist Before You Choose
Check that a provider supports what your app needs before you compare prices:
| Provider | Posting and DMs | MCP for AI agents | SDKs or packages | Published throughput |
|---|---|---|---|---|
| TweetAPI | Yes, including encrypted X Chat, with account credentials | Hosted OAuth server, read-only, open source | Node.js/TypeScript and Python | Trial 2 req/s; PAYG and Pro 20; Ultra 30; Mega 40; Giga 50; Tera 60 |
| GetXAPI | Yes | npm package, with posting and DMs | Not listed | No endpoint quotas advertised; general throttling can return 429 |
| twitterapi.io | Yes, with login cookies | Hosted read-only server and an npm package | Vercel AI SDK and CrewAI packages | 0.2 req/s before any payment; 20 after a payment; 50 on Scale; 500 on Business |
| TwexAPI | Yes, including X Chat, with account credentials | Hosted server with an API key | SDKs and a CLI | 5–30 QPS on paid packages |
| Official X API | Official OAuth | Official XMCP server, self-hosted | Official XDK | Per-endpoint limits plus a 3 million monthly Post-read cap |
| Xquik | Yes, with a connected X account | Hosted server | Yes | Not stated on its pricing page |
| TwitterAPIs | Yes; Post creation and DMs cost $0.0016 | Hosted server with sign-in, plus an npm package; includes posting and DMs | Code examples, no SDK | No caps, per its docs; 600 per minute per key, per its comparison page |
| Sorsa | No, read-only | npm package, read-only | REST only | 20 req/s on every plan |
| SocialData | No, read-only | Yes, billed like REST | REST only | Not stated |
| ScrapeBadger | Check its API reference | Yes, at no extra cost | SDKs | Higher RPM on subscriptions; figures not stated |
| Apify Tweet Scraper | No | Apify's MCP server | Apify API clients | 30–80 Posts per second, as claimed by the actor |
Posting, likes, and DMs need credentials for the X account you control, and they can cost more than reads. A third-party API key is not an official X OAuth token, and paging through results doesn't guarantee a complete history.
TweetAPI also offers managed real-time alerts as a separate service. twitterapi.io, GetXAPI, TwitterAPIs, Xquik, and SocialData offer monitoring inside or alongside their APIs; compare how alerts are delivered, what they cost, and what they cover.
Provider 1: TweetAPI
TweetAPI charges per call and offers three ways to pay: prepaid units (PAYG), a monthly plan, or a plan with PAYG units as a fallback. Public-data calls use a TweetAPI key in the X-API-Key header, so you don't need an X developer app.
| Option | Price and allowance | Cost per 1,000 units | RPM |
|---|---|---|---|
| PAYG | $5/10k, $10/20k, $20/40k, or $50/100k units | $0.50 | 1,200 |
| Pro | $17/month, 100k units | $0.17 | 1,200 |
| Ultra | $57/month, 500k units | $0.114 | 1,800 |
| Mega | $197/month, 2m units | $0.0985 | 2,400 |
| Giga | $417/month, 5m units | $0.0834 | 3,000 |
| Tera | $757/month, 10m units | $0.0757 | 3,600 |
Your free or plan allowance is used first, then PAYG units. Adding units doesn't raise your rate limit, and a plan's higher limit stays in place when you do. The trial gives 100 one-time requests without a credit card. You can pay by card or crypto.
Most calls cost one unit. Sending an X Chat message (/tw-v2/xchat/send) costs 10, and logging in (/tw-v2/auth/login) costs 50. Responses with status 400, 401, 403, 409, 422, or 429 aren't billed, and neither are server errors. Other responses are, including empty results, extra pages, and retries.
PAYG units last 365 days from when the payment settles. A top-up applied while your balance is still valid extends it, but expired units can't be restored. Cancelling a plan keeps your valid PAYG units. The pricing guide covers expiry and top-ups in detail, including what to do if a top-up hasn't been applied yet.
A full page costs the same one unit as a page with one result. PAYG suits light use, a plan suits steady use, and a plan plus PAYG suits a month that runs slightly over. TweetAPI doesn't replace official X OAuth, full-archive search, or the filtered stream. See the OpenAPI specification and the SDK guide for every endpoint.
Provider 2: GetXAPI
GetXAPI's pricing page lists a $10 top-up for about 10,000 standard calls, and those credits never expire. A separate $5 Starter offer covers 4,500 calls for 30 days, once per account, so it can't cover a 5,000-call job on its own.
Its plans show bonuses that only apply in some cases, so the table lists both figures:
| Plan | Monthly price | Base calls | Calls with bonus |
|---|---|---|---|
| Pro | $15 | 30,000 | 40,000 |
| Growth | $49 | 120,000 | 140,000 |
| Scale | $99 | 300,000 | 350,000 |
Some of the extra credits are for paying with crypto, so check which apply to you. Unused plan credits carry over while the plan stays active and expire if it lapses. Heavier endpoints cost more, such as $0.003 for complete user timelines and $0.01 for login.
GetXAPI also has posting and DM endpoints, and managed monitoring from $19/month, billed separately. It advertises no per-endpoint quotas, but its FAQ says general throttling can still apply, so that isn't the same as unlimited throughput. For small jobs, compare its $10 minimum and credit terms with TweetAPI's $5 pack, then check the data each returns. For a head-to-head breakdown, see TweetAPI vs GetXAPI.
Provider 3: twitterapi.io
twitterapi.io's base price list charges $0.15 per 1,000 Posts. Profiles cost $0.18 per 1,000 for small lookups and fall to $0.01 per 1,000 for batches of 100 or more; follower pages fall to $0.01 per 1,000 as page size grows. Every call has a 15-credit ($0.00015) minimum, including calls that return no data. Purchased credits never expire, and recharge bonuses and the up-to-$1 sign-up credit expire after 31 days. That makes it a good fit for sparse results and long gaps between jobs.
Its subscription page offers Starter at $29, Builder at $99, Pro at $199, Scale at $499, and Business at $1,499 a month. Starter includes 2.9 million credits plus an 8% bonus, and Pro 19.9 million plus 26%. At 100,000 credits per dollar, that's $31.32 and $250.74 of usage at the base rate when the bonuses apply. Base plan credits carry over; bonus credits expire after 31 days. It also pays monthly loyalty returns, but those arrive later, so we don't count them as a discount.
Its rate-limit page lists 0.2 requests per second before any payment, 20 after a single purchase or on Starter, Builder, and Pro, 50 on Scale, and 500 on Business. Its Business plan goes above TweetAPI's 60 per second.
Because every Post is billed, full pages cost more. Account actions such as posting, likes, follows, and DMs use login cookies and cost 200 credits ($0.002) each. For a head-to-head breakdown, see TweetAPI vs twitterapi.io.
Provider 4: TwexAPI
TwexAPI charges five credits for a typical public Post or profile read, and five for a response with no data. Requests that fail with an error aren't billed. Its 20,000-credit trial covers about 4,000 typical reads over seven days. Its main packages:
| Package | Payment | Credits | Validity / QPS |
|---|---|---|---|
| Mini | $20 once | 2m | One day / 5 QPS |
| Basic | $50/month | 5m | Monthly refresh / 5 QPS |
| Pro | $99/month | 11m, including 1m bonus | Monthly refresh / 10 QPS |
| Standard | $100 once | 10m | No expiry / 5 QPS |
| Plus | $199 once | 20m | No expiry / 10 QPS |
| Scale | $499 once | 60m | No expiry / 20 QPS |
| Power | $999 once | 120m | No expiry / 30 QPS |
Pro covers 2.2 million typical reads, so $99 works out to $0.045 per 1,000 reads if you use all of it. That's our arithmetic, not a guaranteed cost; TwexAPI's headline rounds it to about $0.05.
Package length and QPS matter: Mini lasts one day, so it can fund a one-day burst but not a job spread over a week. Writes such as posts, replies, and DMs cost 50 credits, and its DM endpoints include X Chat. It accepts card, PayPal, and crypto. Other operations cost different amounts, and we haven't tested its uptime or support claims. For a head-to-head breakdown, see TweetAPI vs TwexAPI.
Provider 5: Official X API
X's official pricing page lists $0.005 per standard Post read, $0.010 per user or follower record, and less for qualifying reads of your own account. Writes are priced separately, such as $0.015 to create a Post. Reading the same resource again within a UTC day is usually not charged twice, though X calls this a soft guarantee.
A 3 million Post-read cap per monthly billing cycle and per-endpoint rate limits apply separately. Reading more Posts than that requires Enterprise.
Choose official access when your product needs official OAuth, first-party fields, archive search, the filtered stream, or a direct contract with X. No third-party API replaces those. The X amounts below are usage values; check the Developer Console for purchase amounts and credit terms.
Provider 6: Xquik
Xquik charges one credit ($0.00015) per delivered result for searches and extractions, and only bills unique results that match your filters, so empty pages cost nothing. X Articles cost five credits, posting a tweet or reply 30 credits ($0.0045), and other writes such as likes and follows 10 credits.
Top-ups start at $10 for 66,666 credits and never expire. Monthly plans are Starter at $20 for 140,000 credits, Pro at $99 for 770,000, and Business at $199 for 1.67 million, and unused plan credits carry over. There is no free plan. Monitors cost 30 credits per hour. Xquik also offers a hosted MCP server and SDKs. Writes need a connected X account.
Provider 7: TwitterAPIs
TwitterAPIs charges $0.0008 per read call and simple write, and $0.0016 for Post creation and DM sends. New accounts get $0.50 of credit without a card, top-ups start at $10, credits never expire, and crypto payments add 2% in credits.
Monitoring is a separate add-on from $15/month, with one monitored account free. Its MCP server is hosted and also published on npm. For a head-to-head breakdown, see TweetAPI vs TwitterAPIs.
Provider 8: Sorsa
Sorsa sells read-only plans that meter one request per call: Starter at $49/month for 10,000 requests, Pro at $199 for 100,000, and larger plans up to $13,990 for 10 million. Every plan has a 20 requests-per-second limit. An optional prepaid overage balance costs from $4.90 per 1,000 extra requests on Starter down to $1.40 on the largest plan. The free tier gives 100 requests that never expire, and requests that return an error are not deducted.
It also offers verification endpoints, such as checking whether a user retweeted or quoted a post. Card plans auto-renew; crypto payments are one-time.
Provider 9: SocialData
SocialData charges $0.0002 per Post or profile returned, or $0.20 per 1,000, with some specialized endpoints priced differently. You deposit any amount, the balance does not expire, and failed requests do not consume it. It is read-only and never acts on your behalf.
There is no free plan, though support can set up a demo account. Its MCP server is billed exactly like the equivalent REST call, and it offers monitoring and social-action checks such as whether a user followed an account or retweeted a post.
Provider 10: ScrapeBadger
ScrapeBadger is a multi-platform scraping API with Twitter/X endpoints and real-time streams. Each endpoint has a fixed credit cost per successful request, and Twitter/X endpoints also charge per item returned. Its pricing page does not list the per-endpoint figures, so check its API reference before modeling a workload.
Pay as you go costs $0.15 per 1,000 credits with a $10 minimum, and those credits do not expire. Subscriptions start at $49/month, and new accounts get 1,000 free credits. Its MCP server uses existing credits at no extra cost.
Provider 11: Apify Tweet Scraper
The Tweet Scraper V2 actor on Apify charges from $0.40 per 1,000 tweets, with Apify Store discounts on higher Apify plans. Each query must return at least 50 tweets. Free Apify users are limited to five runs a month of ten items each and cannot use the actor through the API.
Apify actors suit no-code or scheduled scraping jobs, especially if you already use Apify. Marketplaces such as Apify and RapidAPI host many Twitter data listings from different sellers, so rate limits, uptime, and terms vary by listing.
TweetAPI vs GetXAPI: Where Is the Break-Even Point?
There's no single break-even point. TweetAPI PAYG costs $0.50 per 1,000 calls, and GetXAPI's standard rate is $1 per 1,000. But GetXAPI Pro includes 30,000 calls for $15, or 40,000 with its bonus. At 30,000 calls, TweetAPI PAYG and GetXAPI Pro both cost $15 before fees, with different expiry and rollover terms.
To compare TweetAPI plans with PAYG, see the worked examples in the pricing guide. They show what the units cost, what you pay for whole packs, and what's left over.
At 100,000 calls in one month, TweetAPI Pro costs $17 and GetXAPI Growth costs $49 for 120,000 calls. Heavier endpoints, different returned data, rollover, bonuses, or a need for more throughput can change the answer.
Against per-item pricing, it comes down to how many results each call returns. twitterapi.io charges at least $0.00015 per call, while TweetAPI PAYG costs $0.0005 per call. At three or fewer Posts per call, the per-item model is cheaper; at four or more, per-call is. On TweetAPI Pro ($0.00017 per unit), twitterapi.io is cheaper only for calls that return one Post or none. On Ultra and larger plans, a TweetAPI call costs less than twitterapi.io's minimum charge.
Five Workloads With Different Economics
Each scenario uses normal one-unit read calls, with no free trials, existing balances, empty results, retries, taxes, or fees. Every returned Post counts as billable (for the X API, before its daily deduplication), with no expansions. We assume each provider returns the same data for the same number of calls, which you should check. Requests peak at 30 per minute, spread over the period, so check each provider's limits before you schedule a real job.
“Usage” is the work priced at the provider's base rate. “What covers it” is a published package that pays for the job, not necessarily the cheapest checkout, and leftovers follow each provider's terms above. For twitterapi.io, we don't assume a top-up minimum, which isn't published, or count future loyalty returns.
1. Occasional dense collection: 5,000 calls, 20 Posts each
The job returns 100,000 Posts over seven days.
| Provider | Usage | What covers it, and what's left |
|---|---|---|
| TweetAPI | 5,000 units; $2.50 PAYG value | $5 pack; 5,000 wallet units left |
| GetXAPI | $5 at the standard rate | $10 top-up; $5 left. The $5 Starter isn't enough |
| twitterapi.io | $15 at the base rate | Top-up amounts aren't published. The $29 Starter plan covers it, with $16.32 left if its bonus applies |
| TwexAPI | 500,000 credits | $50 Basic; 4.5m credits left this cycle. Mini lasts one day, too short for this job |
| Official X API | $500 at the standard rate | Check the Developer Console for purchase amounts |
2. Sparse collection: 5,000 calls, one Post each
Over the same seven days, TweetAPI still uses 5,000 units (a $5 pack) and GetXAPI still uses $5 of calls (a $10 top-up). Per-call prices don't change when pages are sparse.
For twitterapi.io, usage falls to $0.75, so a small top-up could beat the $29 plan; the exact amount depends on its checkout. Per-item pricing wins here.
TwexAPI needs 25,000 credits; Basic costs $50 and leaves 4,975,000 credits this cycle. The X API's usage falls to $25. When most of a package goes unused, expiry and whether you can reuse the credits matter most.
3. Steady month: 100,000 calls, 20 Posts each
This is two million Post reads in one billing cycle.
| Provider | Usage | What covers it, and what's left |
|---|---|---|
| TweetAPI | 100,000 units | $17 Pro; no allowance left |
| GetXAPI | $100 at the standard rate | $49 Growth covers it; 20,000 calls left, or 40,000 with its bonus |
| twitterapi.io | $300 at the base rate | $199 Pro gives $250.74 with its bonus, so it needs a top-up. $499 Scale gives $698.60 and covers it |
| TwexAPI | 10m credits | $99 Pro; 1m credits left this cycle. A $100 Standard pack also covers it, with nothing left |
| Official X API | $10,000 at the standard rate | Within the 3m monthly cap, before other usage; check the console for purchase amounts |
So twitterapi.io's $199 Pro plan doesn't cover this job on its own, but with its plan bonuses the real cost can land below the $300 base rate.
The other six providers on workloads 1 and 3
The same assumptions apply: 20 Posts per call, no trials, no empty results. Per-call prices stay the same however many results a page returns; per-item prices rise as pages get fuller and fall as they get emptier.
| Provider | Workload 1: 5,000 calls, 100,000 Posts | Workload 3: 100,000 calls, 2m Posts |
|---|---|---|
| Xquik | $15 PAYG value; $20 Starter (140,000 credits) covers it | $300 PAYG value; $199 Business plus a $50 top-up (2,003,333 credits) covers it |
| TwitterAPIs | $4 value; a $10 top-up leaves $6 | $80 value |
| Sorsa | $49 Starter; 5,000 requests left in the month | $199 Pro; no requests left |
| SocialData | $20 value | $400 value |
| ScrapeBadger | Not modeled: per-endpoint credits are not on its pricing page | Not modeled |
| Apify Tweet Scraper | $40 value, on a paid Apify plan that allows API use | $800 value before Apify Store discounts |
On both workloads, TweetAPI costs less than every provider modeled in this table. TwitterAPIs costs more per call than TweetAPI PAYG ($0.0008 versus $0.0005), and the per-item providers cost more as pages get denser. Throughput, endpoint coverage, payment terms, and expiry can still outweigh the price difference.
4. Slightly over quota: 120,000 calls, 20 Posts each
This is 2.4 million Post reads spread through one cycle.
| Provider | Usage | What covers it, and what's left |
|---|---|---|
| TweetAPI | 120,000 units | $17 Pro plus a $10 top-up for 20,000 units = $27; nothing left |
| GetXAPI | $120 at the standard rate | $49 Growth covers it exactly; its bonus would leave 20,000 calls |
| twitterapi.io | $360 at the base rate | $199 Pro plus a top-up, or $499 Scale with $338.60 left if its bonus applies |
| TwexAPI | 12m credits | $199 Plus covers it and leaves 8m credits that don't expire; $99 Pro alone isn't enough |
| Official X API | $12,000 at the standard rate | Within the 3m monthly cap, before other usage; check the console |
Plus isn't necessarily TwexAPI's cheapest option here. If the overflow happens within one day, Pro plus a Mini might work for $119; check first that packages stack and when each one expires.
5. Usage across months: 5,000 dense calls in each of two cycles
Assume 20 Posts per call and both jobs finish within 60 days: 10,000 calls and 200,000 Posts in total.
| Provider | Usage | What covers it |
|---|---|---|
| TweetAPI | 10,000 units; $5 on PAYG | One $5 pack covers both jobs, with nothing left. Two months of Pro would cost $34 |
| GetXAPI | $10 at the standard rate | One $10 top-up covers both, and it doesn't expire. Two months of Pro at $15 also work; unused plan credits need an active plan |
| twitterapi.io | $30 at the base rate | Purchased credits don't expire, so one top-up can cover both; the amount isn't published. Two months of Starter cost at least $58 |
| TwexAPI | 1m credits | $100 Standard leaves 9m credits that don't expire. Two months of Basic also cost $100, but unused credits reset each month |
| Official X API | $1,000 at the standard rate | 100,000 Post reads per cycle, before other usage; check the console for credit terms |
If the second TweetAPI job runs after the PAYG units' 365-day expiry, with no top-up in between, you'd need another pack. For long gaps between jobs, credits that never expire can be worth a larger first payment. Check each provider's rules before counting on plan allowances or bonus credits carrying over.
Copyable Workload Cost Calculator
This calculator compares the cost of normal Post reads across providers, and TweetAPI's payment options across billing cycles. It makes no API calls. callsByCycle counts only non-empty, billable reads, and postsPerCall is the same whole number for every response. It leaves out empty responses and retries, but real billing doesn't. For logins and X Chat messages, which cost more units, use the unit budget calculator in the pricing guide.
function comparePostReads({ callsByCycle, postsPerCall, periodDays, peakRpm = 30 }) {
if (
!Array.isArray(callsByCycle) || callsByCycle.length === 0 ||
!callsByCycle.every((n) => Number.isSafeInteger(n) && n >= 0) ||
!Number.isSafeInteger(postsPerCall) || postsPerCall < 1 ||
!Number.isFinite(periodDays) || periodDays <= 0 || periodDays >= 365 ||
!Number.isFinite(peakRpm) || peakRpm <= 0
) throw new Error("Use valid cycle counts, positive whole Posts, and a period below 365 days.");
const calls = callsByCycle.reduce((sum, n) => sum + n, 0);
const posts = calls * postsPerCall;
if (calls < 1 || !Number.isSafeInteger(posts * 15)) throw new Error("Invalid workload size.");
function fundTweetApi(price, allowance, rpm) {
let cash = 0;
let wallet = 0;
for (const used of callsByCycle) {
const paygNeeded = Math.max(0, used - allowance);
const bought = Math.ceil(Math.max(0, paygNeeded - wallet) / 10_000) * 10_000;
cash += price + bought * 0.0005;
wallet += bought - paygNeeded;
}
return { cash, walletUnitsLeft: wallet, fitsPeakRpm: peakRpm <= rpm };
}
const xFitsMonthlyCap = callsByCycle.every((n) => n * postsPerCall <= 3_000_000);
return {
calls, posts,
tweetapiUnits: calls, // Normal reads only: one unit each.
tweetapiPayg: fundTweetApi(0, 0, 1_200),
tweetapiProHybrid: fundTweetApi(17, 100_000, 1_200),
tweetapiUltraHybrid: fundTweetApi(57, 500_000, 1_800),
getxapiStandardUsageValue: calls / 1_000,
twitterapisUsageValue: calls * 8 / 10_000,
twitterapiIoBaseUsageValue: posts * 15 / 100_000,
xquikPaygUsageValue: posts * 15 / 100_000,
socialdataUsageValue: posts * 2 / 10_000,
twexapiCreditsNeeded: posts * 5,
xStandardUsageValue: xFitsMonthlyCap ? posts / 200 : "Enterprise review required",
xFitsMonthlyCap,
};
}
console.log(comparePostReads({
callsByCycle: [5_000, 5_000],
postsPerCall: 20,
periodDays: 60,
}));
The example prints $5 for TweetAPI PAYG with no units left, against $34 for two months of Pro. Its base usage values are $10 for GetXAPI, $8 for TwitterAPIs, $30 each for twitterapi.io and Xquik, and $40 for SocialData. These aren't checkout prices: apply the plans, minimum top-ups, and expiry rules above before comparing what you'd pay. TwexAPI needs one million credits, and the X API's usage value is $1,000 before deduplication.
The calculator assumes you start with no trial or balance, that PAYG units stay valid for the whole period, and that you renew the same TweetAPI plan every cycle, even idle ones. It carries unused PAYG units forward and resets plan allowances. It doesn't model upgrades, expired units, bonuses, other providers' top-up rounding, volume tiers, or real throughput. It rejects periods of 365 days or more instead of counting expired credits.
Test TweetAPI With Your Own Workload
Published prices only tell you so much. The 100-request trial needs no credit card, so you can run the calls your app actually makes:
- Pick a sparse lookup, a dense search, and a short paginated collection that match your app. Set a page budget before you start.
- Record the endpoint, parameters, HTTP status, usable records, missing fields, duplicate IDs, cursor progress, and response time. Keep API keys out of the log.
- Check your usage before and after each run, so you see exactly what was billed, including empty results and retries.
- If you already use another provider, run the same calls there and compare the cost per usable record, the credit left over, and the throughput you need.
- Use the calculator above to project a full month.
A few successful calls don't prove long-term reliability, so keep measuring once you're in production.
Frequently Asked Questions
Which provider is cheapest for a few thousand calls?
It depends on how many results each call returns. For dense pages, TweetAPI PAYG has the lowest rate among the per-call providers here: $0.50 per 1,000 calls, from a $5 pack. TwitterAPIs and GetXAPI top-ups start at $10, and twitterapi.io, Xquik, and SocialData can have very low usage value when results are sparse. Minimum payments, density, expiry, and credits you already own determine what you actually pay.
Does PAYG mean unlimited rate limits or free empty results?
No. A balance pays for requests; it doesn't remove rate limits. Empty results use TweetAPI units, and twitterapi.io and TwexAPI also charge for calls that return no data. Xquik doesn't bill empty or filtered pages. Check how each endpoint bills results and retries.
Which alternatives support posting, DMs, and MCP?
TweetAPI, TwitterAPIs, GetXAPI, Xquik, twitterapi.io, and TwexAPI document posting and DM endpoints that use account credentials. TweetAPI and TwexAPI also document encrypted X Chat. Sorsa and SocialData are read-only. Most providers here offer an MCP server; TweetAPI's is a hosted OAuth server with read-only tools.
Can I use these alternatives without an X developer account?
Yes. Independent providers issue their own API keys for public data. The official X API needs its own developer account and tokens. Actions on an account, such as posting, need credentials for that account either way.
Are third-party Twitter APIs official or endorsed by X?
No. Use official X access when you need first-party authorization or a direct relationship with X, and review each provider's terms for your use case.
Sources and Next Steps
Figures come from each provider's own pricing and documentation pages: GetXAPI, twitterapi.io, TwexAPI, the official X API, Xquik, TwitterAPIs, Sorsa, SocialData, ScrapeBadger, and the Apify Tweet Scraper. Rate limits, subscriptions, and caps come from the same sites' plan and documentation pages. TweetAPI's options and billing rules are explained in the pricing guide and terms.
Test TweetAPI with your own workload before buying a larger package. The 100-request trial needs no credit card.