Back to Blog
comparisontwitter apialternativespricingx api

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.

TweetAPI
28 min read

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.

ProviderMonthly costBasis
TweetAPI$17Pro plan
GetXAPI$49Growth plan
TwitterAPIs$80$0.0008 per call
TwexAPI$99Pro plan
Sorsa$199Pro plan
Xquik$249Business plan plus a $50 top-up
twitterapi.io$300Base 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:

WorkloadCandidates to compareWhat matters
Occasional page-based collectionTweetAPI PAYG, GetXAPI top-ups, TwitterAPIsMinimum purchase, request weight, remaining credits, expiry
Steady monthly collectionTweetAPI plans/hybrid, GetXAPI subscriptions, TwexAPI subscriptionsPlan allowance, bonuses, rate limits
Sparse responses or long gaps between jobsTweetAPI PAYG, twitterapi.io, Xquik, SocialData, GetXAPI top-ups, TwexAPI packsPer-item versus per-call charges; credit expiry
Short bursts above a few requests per secondTweetAPI Giga or Tera (50–60 per second), twitterapi.io, Sorsa, or TwexAPI's larger packsThe rate limit your account actually gets
Posting, DMs, and reads with one keyTweetAPI, TwitterAPIs, GetXAPI, Xquik, twitterapi.io, TwexAPIWhich actions exist, what each write costs, and which credentials they need
Read-only data and verification checksTweetAPI (follow checks), Sorsa, SocialDataBatch sizes, check endpoints, plan minimums
No-code scraping runsApify Tweet ScraperPer-result price, per-query minimums, Apify plan limits
Official OAuth, archive, filtered stream, or direct procurementOfficial X APIOfficial 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

ProviderBilling unitEntry paymentFree trialPaid credit expiry
TweetAPIPer call: 1 unit for most calls$5/10,000 prepaid units; plans from $17/month100 one-time units, no cardPAYG: 365 days, extendable by later top-ups; plans: billing-cycle allowance
GetXAPIPer call: $0.001 for most reads$10 top-ups; $5 one-time Starter; plans from $15/month$0.10Top-ups never expire; plan credits roll over while the plan is active
twitterapi.ioPer item: $0.15/1,000 Posts, 15-credit minimum per callTop-ups; plans from $29/monthUp to $1, expires after 31 daysPaid credits never expire; bonus credits expire after 31 days
TwexAPIPer item: 5 credits per typical read$20 Mini; plans from $50/month; one-time packs from $10020,000 credits for 7 daysMini: one day; subscriptions: monthly refresh; Standard and larger packs: no expiry
Official X APIPer item: $0.005 per Post readPrepaid credits in the Developer ConsoleNone; $20 of credit after your first purchaseCheck the Developer Console terms
XquikPer item: $0.00015 per delivered result$10 top-ups; plans from $20/monthNoneTop-ups never expire; plan credits carry over
TwitterAPIsPer call: $0.0008 for readsTop-ups from $10$0.50Credits never expire
SorsaPer call: one request from a monthly plan$49/month for 10,000 requests100 requests that never expireMonthly plan allowance; optional prepaid overage
SocialDataPer item: $0.20/1,000 Posts or profilesPrepaid balance, any amountNone; demo on requestBalance does not expire
ScrapeBadgerCredits per request; $0.15/1,000 credits on PAYG$10 PAYG; plans from $49/month1,000 creditsPAYG credits do not expire
Apify Tweet ScraperPer item: from $0.40/1,000 PostsAn Apify plan that allows API useApify free plan: 5 runs a month, 10 items each, no APIFollows 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:

ProviderPosting and DMsMCP for AI agentsSDKs or packagesPublished throughput
TweetAPIYes, including encrypted X Chat, with account credentialsHosted OAuth server, read-only, open sourceNode.js/TypeScript and PythonTrial 2 req/s; PAYG and Pro 20; Ultra 30; Mega 40; Giga 50; Tera 60
GetXAPIYesnpm package, with posting and DMsNot listedNo endpoint quotas advertised; general throttling can return 429
twitterapi.ioYes, with login cookiesHosted read-only server and an npm packageVercel AI SDK and CrewAI packages0.2 req/s before any payment; 20 after a payment; 50 on Scale; 500 on Business
TwexAPIYes, including X Chat, with account credentialsHosted server with an API keySDKs and a CLI5–30 QPS on paid packages
Official X APIOfficial OAuthOfficial XMCP server, self-hostedOfficial XDKPer-endpoint limits plus a 3 million monthly Post-read cap
XquikYes, with a connected X accountHosted serverYesNot stated on its pricing page
TwitterAPIsYes; Post creation and DMs cost $0.0016Hosted server with sign-in, plus an npm package; includes posting and DMsCode examples, no SDKNo caps, per its docs; 600 per minute per key, per its comparison page
SorsaNo, read-onlynpm package, read-onlyREST only20 req/s on every plan
SocialDataNo, read-onlyYes, billed like RESTREST onlyNot stated
ScrapeBadgerCheck its API referenceYes, at no extra costSDKsHigher RPM on subscriptions; figures not stated
Apify Tweet ScraperNoApify's MCP serverApify API clients30–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.

OptionPrice and allowanceCost per 1,000 unitsRPM
PAYG$5/10k, $10/20k, $20/40k, or $50/100k units$0.501,200
Pro$17/month, 100k units$0.171,200
Ultra$57/month, 500k units$0.1141,800
Mega$197/month, 2m units$0.09852,400
Giga$417/month, 5m units$0.08343,000
Tera$757/month, 10m units$0.07573,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:

PlanMonthly priceBase callsCalls with bonus
Pro$1530,00040,000
Growth$49120,000140,000
Scale$99300,000350,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:

PackagePaymentCreditsValidity / QPS
Mini$20 once2mOne day / 5 QPS
Basic$50/month5mMonthly refresh / 5 QPS
Pro$99/month11m, including 1m bonusMonthly refresh / 10 QPS
Standard$100 once10mNo expiry / 5 QPS
Plus$199 once20mNo expiry / 10 QPS
Scale$499 once60mNo expiry / 20 QPS
Power$999 once120mNo 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.

ProviderUsageWhat covers it, and what's left
TweetAPI5,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 rateTop-up amounts aren't published. The $29 Starter plan covers it, with $16.32 left if its bonus applies
TwexAPI500,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 rateCheck 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.

ProviderUsageWhat covers it, and what's left
TweetAPI100,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
TwexAPI10m 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 rateWithin 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.

ProviderWorkload 1: 5,000 calls, 100,000 PostsWorkload 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
ScrapeBadgerNot modeled: per-endpoint credits are not on its pricing pageNot 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.

ProviderUsageWhat covers it, and what's left
TweetAPI120,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
TwexAPI12m 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 rateWithin 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.

ProviderUsageWhat covers it
TweetAPI10,000 units; $5 on PAYGOne $5 pack covers both jobs, with nothing left. Two months of Pro would cost $34
GetXAPI$10 at the standard rateOne $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 ratePurchased credits don't expire, so one top-up can cover both; the amount isn't published. Two months of Starter cost at least $58
TwexAPI1m 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 rate100,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:

  1. Pick a sparse lookup, a dense search, and a short paginated collection that match your app. Set a page budget before you start.
  2. Record the endpoint, parameters, HTTP status, usable records, missing fields, duplicate IDs, cursor progress, and response time. Keep API keys out of the log.
  3. Check your usage before and after each run, so you see exactly what was billed, including empty results and retries.
  4. 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.
  5. 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.