Twitter API alternative for reading public X posts in 2026

Last updated: October 21, 2026. X prices checked on docs.x.com the same day.

TL;DR: For read-only work on public X data, a Twitter API alternative that bills per request is usually far cheaper than X's pay-per-use API, which bills per resource. Reading 20 recent posts from one account costs $0.10 on X ($0.005 per post read) and 2 credits ($0.0018 to $0.005) on Scrape Everything.

If you need to post, send DMs, search by keyword or read protected accounts, stay on the official X API.

What changed in X API pricing in 2026?#

On February 6, 2026, X launched pay-per-use pricing for the X API. It followed a limited closed pilot announced on October 20, 2025. You prepay credits in the Developer Console, with no subscription.

According to the X developer changelog, Basic and Pro plans remain available and existing subscribers can opt in to pay-per-use. Recently active Legacy Free users got a one-time $10 voucher. Public Utility Apps keep free access.

These are the prices that matter here, from X's API pricing page:

The headline prices matter less than the fine print on that page:

1. Billing is per resource, not per request. A timeline call that returns 20 posts is 20 post reads.
2. Deduplication runs on a 24-hour UTC day window. Fetch the same post twice before midnight UTC and you pay once. X calls this a "soft guarantee", since outages and other edge cases can break it.
3. Pay-per-use is capped at 3 million post reads per monthly billing cycle. Past that, X points you to Enterprise.
4. Spend $200 or more in a billing cycle and X gives you xAI API credits back, starting at 10% and rising to 20% at $1,000 and up.

The April 16, 2026 pricing update also removed following, liking and quote-posting from all self-serve tiers. Prices have moved several times this year, so check the official page before you budget.

How much does it cost to read tweets with the X API?#

Most people who search "Twitter API pay per use" never write a post. They want follower counts for 40 brands or the view count on one campaign post. On X, that read-only work scales with how much data comes back: one profile is $0.010, one post is $0.005, a 60-post timeline is $0.30.

A request-priced API flips that. One call costs the same whether it returns 5 posts or 60.

Writes are different. Public-data APIs can't post or DM as your account.

You shouldn't want one that tries.

What does a public-data API return for X?#

An X (Twitter) scraper API returns public X data (profiles, timelines and single posts) as JSON from a username or post link, without a paid X API tier. Scrape Everything is a REST API for public social media data, returned as clean JSON. X is one of its 9 platforms, alongside Instagram, TikTok, YouTube, Facebook, Telegram, Spotify, Pinterest and Twitch.

There are three X endpoints. Credit costs come straight from our catalog:

Send post IDs as strings. Modern X IDs are 19 digits, well past 2^53 (9,007,199,254,740,992), where JavaScript numbers stop representing integers exactly. A numeric ID can quietly become a different post's ID somewhere in your stack.

How do I fetch an account's recent posts with cURL?

curl -X POST https://api.scrapeeverything.com/v1/x/posts \
  -H "Authorization: Bearer $SCRAPEEVERYTHING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "example_user", "limit": 20}'

A trimmed response (placeholder values, real field names):

{
  "success": true,
  "data": {
    "user_id": "1234567890",
    "username": "example_user",
    "full_name": "Example User",
    "is_private": false,
    "is_blue_verified": true,
    "follower_count": 48210,
    "tweet_count": 9132,
    "posts": [
      {
        "id": "1850000000000000001",
        "link": "https://x.com/example_user/status/1850000000000000001",
        "text": "Shipping the v2 changelog today.",
        "lang": "en",
        "created_at": "Tue Oct 20 14:03:11 +0000 2026",
        "author_username": "example_user",
        "is_pinned": false,
        "is_retweet": false,
        "is_reply": false,
        "reply_count": 12,
        "retweet_count": 40,
        "like_count": 310,
        "bookmark_count": 18,
        "view_count": 22450,
        "media": []
      }
    ],
    "posts_fetched": 20,
    "has_more": true
  },
  "meta": {
    "request_id": "req_example",
    "cached": false,
    "credits_charged": 2,
    "credits_remaining": 98
  }
}

created_at uses X's legacy format (Wed Jun 02 20:12:29 +0000 2010), not ISO 8601. In Python it's one line: datetime.strptime(s, "%a %b %d %H:%M:%S %z %Y").

Is it cheaper than the X API?#

For public reads, yes, at every pack size. Our pricing is one-time credit packs, and credits never expire:

Packs are paid in crypto. Enterprise (1M+ credits) is on request. The pricing page always has the current packs.

Same jobs, both models (our range runs from the Scale rate to the Builder rate):

The break-even: 2 credits cost about $0.0031 at the Builder rate, under the $0.005 of one X post read. So a timeline call costs less in credits even when it returns a single post, at every pack size.

Two things cut the official bill. The dedup window makes repeat reads within a UTC day free. And X's user posts timeline accepts since_id, which returns only posts newer than the last one you saw. On our side, failed requests are refunded automatically and cache hits are free.

X wins outright on owned reads: $0.001 for your own posts and bookmarks, which no public-data API can see anyway.

Plug in your own volumes with the pricing calculator. For other scraping vendors across all platforms, see social media scraping API pricing compared.

Which Twitter API alternative should I use?#

Here's how the main X API alternatives compare, using only what each vendor publishes on its pricing page (checked October 22, 2026). Prices may change, so confirm before you buy.

Product names are trademarks of their owners; we are not affiliated with them. Figures from each vendor's public pricing page, verified October 22, 2026. Spot an error? Email [email protected] and we correct it.

EnsembleData lists Twitter among its platforms and suits a steady daily workload. On Apify, X scrapers are Actors, often from third parties, each priced separately. Bright Data targets enterprise contracts and datasets. DIY looks free until you count the hours spent fixing it after X changes its pages. Our side-by-side vendor comparisons go into each one in more detail.

When should you stay on the official X API?#

Plenty of cases. I'd pick the official API without thinking twice if any of these apply:

• You post, reply, like or send DMs. A read-only API can't do any of it.
• You need keyword search. Our X endpoints don't have it today; X's API does.
• You need protected accounts or your own bookmarks.
• You need older posts. We return up to 60; X's user timeline goes back 3,200.
• Procurement requires a direct contract with the platform. We're unofficial.
• You need streaming. We're request/response only.

Example: how much does it cost to monitor 50 accounts' latest posts daily?#

Say you track 50 competitor and industry accounts and want their latest 20 posts once a day for a dashboard.

1. Get an API key. You get 100 free credits on signup, no payment details needed.
2. Put the 50 usernames in a list.
3. Call /v1/x/posts once per account with limit: 20.
4. Store posts by id and update the counts on ones you've already seen.

Here's that loop in Python, with retries for the errors you'll actually hit:

import os
import time
from datetime import datetime

import requests

API = "https://api.scrapeeverything.com/v1/x/posts"
HEADERS = {"Authorization": f"Bearer {os.environ['SCRAPEEVERYTHING_API_KEY']}"}

accounts = ["example_user", "example_brand", "example_founder"]  # your 50 handles


def fetch(handle, attempt=0):
    r = requests.post(API, headers=HEADERS, json={"username": handle, "limit": 20}, timeout=90)
    if r.status_code in (429, 502, 503, 504) and attempt < 4:
        reset = r.headers.get("RateLimit-Reset")
        wait = int(reset) if r.status_code == 429 and reset else 2 ** attempt
        time.sleep(wait)
        return fetch(handle, attempt + 1)
    try:
        return r.json()
    except ValueError:
        return {"success": False, "code": f"HTTP_{r.status_code}", "message": r.text[:200]}


seen = {}
for handle in accounts:
    body = fetch(handle)
    if not body.get("success"):
        # e.g. NOT_FOUND: the account doesn't exist. Drop it from your list.
        print(handle, body.get("code"), body.get("message"))
        continue
    data = body["data"]
    if data["is_private"]:
        print(handle, "is protected, no posts returned")
        continue
    for post in data["posts"]:
        seen[post["id"]] = {
            "author": post["author_username"],
            "created_at": datetime.strptime(post["created_at"], "%a %b %d %H:%M:%S %z %Y"),
            "likes": post["like_count"],
            "views": post["view_count"],
        }
    print(handle, data["posts_fetched"], "posts, credits charged:", body["meta"]["credits_charged"])

print(len(seen), "unique posts stored")

A failed lookup comes back in the same JSON shape, for example {"success": false, "message": "User not found", "code": "NOT_FOUND", ...}. The retry logic follows our rate limit docs.

The math on our side: 50 calls × 2 credits = 100 credits a day, or 3,000 credits over 30 days. The $39 Builder pack (25,000 credits) covers about eight months of it. Get 100 free credits and run it on three accounts first.

The same job on X's pay-per-use API is 1,000 post reads a day. At $0.005 each that's $5.00 a day, about $150 over 30 days. Each day is a new UTC window, so yesterday's posts are billed again if they show up in the next day's response.

since_id brings that down. At an assumed 5 new posts per account per day, you'd read 250 posts: $1.25 a day, about $37.50 a month. The catch: you stop refreshing likes and views on older posts, which is usually the point of a monitoring dashboard.

What does it cost at 1,000 accounts?

Same job, 1,000 accounts, 20 posts each, daily. On X that's 20,000 post reads a day, $100 a day, about $3,000 over 30 days (600,000 reads, inside the 3M cap). With us it's 2,000 credits a day, 60,000 a month, which fits in the $119 Growth pack with 40,000 credits left.

At 1,000 accounts the gap is about $119 against $3,000 a month.

Reruns don't cost extra on our side. Blocked, timed-out and other failed scrapes are refunded automatically. A 404 NOT_FOUND is a final answer and is billed, so drop that handle instead of retrying. If you rerun the same list the same day, say after a bug in your parsing step, add "cache_days": 1 to each request and the second pass comes from the cache for 0 credits.

Rate limits are per account (requests per minute and concurrent requests) and go up once your purchases total $39 or more (a Builder pack or larger does it at once). Current numbers are on the rate limits page.

Can I call it from Node, an AI agent or n8n?#

Yes. Here's the profile endpoint with Node's built-in fetch (Node 18+):

const res = await fetch("https://api.scrapeeverything.com/v1/x/profile", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SCRAPEEVERYTHING_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ username: "example_user" }),
});
const { success, data, meta, code } = await res.json();
console.log(success ? `${data.username}: ${data.follower_count} followers (${meta.credits_charged} credit)` : code);

No code at all? The MCP server (@scrapeeverything/mcp, in the official MCP Registry) gives Claude, Cursor and other Model Context Protocol clients X lookups as tools. The n8n node runs the monitoring loop on a schedule. There's also a CLI (npx scrapeeverything) and an OpenAPI spec at https://scrapeeverything.com/openapi.json.

What are the limits of a read-only X API?#

Beyond the no-writes, no-search points above, here's the rest without the sales voice:

• Timelines stop at 60 items. has_more: true tells you older posts exist; we don't page past them.
• Protected accounts return an empty posts array, with the public profile fields and is_private: true.
• You see what a logged-out visitor sees. Posts X hides from logged-out visitors are missing.
• No follower lists, only follower and following counts.
• It's unofficial. We're not affiliated with X, and X can change what logged-out pages show at any time.

Public data still comes with obligations, especially around personal data, and X has its own Terms of Service you should read. We wrote up what we know in is scraping public social media data legal. It isn't legal advice. Ask your own counsel before you process personal data at scale.

FAQ#

Is there a cheap Twitter API for reading tweets?

On X's official pay-per-use plan, each post read costs $0.005 and each user read $0.010. Scrape Everything charges 1 credit per profile or single post and 2 credits for a profile plus up to 60 recent posts, with one-time credit packs from $39 for 25,000 credits.

Does X still have a free API tier in 2026?

Not for most developers. Per X's February 6, 2026 changelog, Public Utility Apps keep free access and recently active Legacy Free users got a one-time $10 voucher. Everyone else pays.

Do I need an X developer account to use a Twitter API alternative?

Not for Scrape Everything. You sign in with Google or GitHub and use an API key. No X developer account or OAuth.

Can a Twitter API alternative search tweets by keyword?

Ours can't today. The X endpoints cover profiles, recent timelines up to 60 posts, and single posts by URL or ID. For keyword search, use the official X API.

How do I get more than 60 tweets from one account?

Not with us. Our timeline stops at the 60 most recent items. X's official user posts timeline returns up to the 3,200 most recent posts, and older posts need X's full-archive search.

Can I read protected X accounts?

No. Protected accounts return their public profile fields with is_private: true and an empty posts array. Their posts aren't visible to logged-out visitors, so a public-data API can't return them.

Try it on your own account list#

Pick five handles you care about, run the cURL example on each, and put the cost next to what X's pricing page would charge for the same posts. The X scraper API overview lists every X endpoint with its fields and credit cost.

Get 100 free credits