Best Twitter scrapers in 2026: cost and risk

#What a Twitter scraper does in 2026

A Twitter scraper is a tool that collects public X data, such as posts, profiles and follower lists, by reading x.com's pages or replaying the requests x.com makes, instead of buying the data through an API. Our guide on how to scrape Twitter covers each way and what breaks it; this page compares the tools you would install or pay for.

Since X moved most of the site behind its login, a scraper's reach depends on whose account it uses. On November 2, 2026, x.com showed a logged-out visitor single posts and the first 9 posts of a profile, and sent search and follower lists to the login page.

Four kinds of tools do that work today:

• Browser extensions save what your own logged-in x.com tab shows as you scroll, so every page they read is a page your account opened, one screen at a time.
• Open-source libraries, such as twscrape and Scweet, replay x.com's internal requests with the cookies of X accounts you log in. They charge nothing and break each time X changes those requests.
• Hosted scraping tools, from actor stores to no-code templates, run the collection on their own servers and bill per result, from $0.15 to $1.50 per 1,000 posts. Apify's FAQ (opens in a new tab) says detailed follower lists need session cookies.
• Page-rendering scraping APIs fetch one public x.com page per request through proxies and hand back its HTML, so search results and follower lists stay out of their reach.

#Do a scraper's job with one API key

To collect public posts, profiles and followers with no X login, use Sorsa API, a Twitter (X) API and scraper: one key in the ApiKey header returns JSON, about 20 search results per request from $0.07 per 1,000, or 100 posts by link from $0.014 per 1,000.

Sorsa API never asks for your X login or cookies, so none of your X accounts is at risk. When X changes its site, the fix happens on Sorsa API's side and your code keeps working. Every plan runs at 20 requests per second, and search reaches back to 2006 with X's advanced search operators.

1. Get a key. Sign up and copy your API key from the dashboard. It comes with 100 free requests, no card, and they never expire.

2. Search for posts. Send any X search query to POST /search-tweets (opens in a new tab); keywords, quoted phrases, from:, lang:, since: and min_faves: all work.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "\"customer support\" lang:en min_faves:20", "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "1984632215088140901",
         "full_text": "Support queue is down to 2 hours. Here is what changed.",
         "created_at": "2026-11-01T16:42:09Z",
         "lang": "en",
         "likes_count": 312,
         "retweet_count": 41,
         "reply_count": 27,
         "quote_count": 6,
         "view_count": 48210,
         "user": {
           "id": "1712093388410273792",
           "username": "supportdesk_weekly",
           "display_name": "Support Desk Weekly",
           "followers_count": 18300,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG4hXa0UkYRw"
   }
   

   Show full response

3. Save every page to a CSV file. Each response carries next_cursor, a pointer to the next page of results; send it back in the body until it comes back empty.

   import csv
   import os
   
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   KEY = os.environ.get("SORSA_API_KEY", "YOUR_API_KEY")
   QUERY = '"customer support" lang:en min_faves:20'
   
   
   def pages(query, limit=50):
       body = {"query": query, "order": "latest"}
       for _ in range(limit):
           r = requests.post(URL, json=body, headers={"ApiKey": KEY}, timeout=30)
           r.raise_for_status()
           data = r.json()
           yield data["tweets"]
           body["next_cursor"] = data.get("next_cursor")
           if not body["next_cursor"]:
               break
   
   
   with open("posts.csv", "w", newline="", encoding="utf-8") as f:
       out = csv.writer(f)
       out.writerow(["id", "created_at", "author", "likes", "views", "text"])
       for batch in pages(QUERY):
           for t in batch:
               out.writerow([t["id"], t["created_at"], t["user"]["username"],
                             t["likes_count"], t["view_count"], t["full_text"]])
   

   import { writeFileSync } from "node:fs";
   
   const URL = "https://api.sorsa.io/v3/search-tweets";
   const KEY = process.env.SORSA_API_KEY ?? "YOUR_API_KEY";
   const body = {
     query: '"customer support" lang:en min_faves:20',
     order: "latest",
   };
   const rows = [["id", "created_at", "author", "likes", "views", "text"]];
   
   for (let page = 0; page < 50; page++) {
     const res = await fetch(URL, {
       method: "POST",
       headers: { ApiKey: KEY, "Content-Type": "application/json" },
       body: JSON.stringify(body),
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     const data = await res.json();
     for (const t of data.tweets) {
       rows.push([t.id, t.created_at, t.user.username,
         t.likes_count, t.view_count, t.full_text]);
     }
     if (!data.next_cursor) break;
     body.next_cursor = data.next_cursor;
   }
   
   const cell = (v) => `"${String(v).replace(/"/g, '""')}"`;
   writeFileSync("posts.csv", rows.map((r) => r.map(cell).join(",")).join("\n"));
   

4. Look up posts you already have links to. POST /tweet-info-bulk (opens in a new tab) takes up to 100 post URLs or IDs in one request, where a page-rendering scraper opens one page per post.

   curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_links": [
           "https://x.com/supportdesk_weekly/status/1984632215088140901",
           "1984599871204427808"]}'
   

The jobs people buy scraping tools for map one to one onto Sorsa API endpoints, and each request is billed once, whatever it returns:

• Posts matching a search

  Sorsa API endpoint

  POST /search-tweets

  Per request

  about 20 posts

  On x.com logged out

  A redirect to the login page

• An account's posts

  Sorsa API endpoint

  POST /user-tweets (opens in a new tab)

  Per request

  about 20 posts

  On x.com logged out

  The first 9 posts, then a login wall

• Posts from a list of links

  Sorsa API endpoint

  POST /tweet-info-bulk

  Per request

  up to 100 posts

  On x.com logged out

  One post per page load

• Followers of an account

  Sorsa API endpoint

  GET /followers (opens in a new tab)

  Per request

  up to 200 followers

  On x.com logged out

  A redirect to the login page

• Profiles by username

  Sorsa API endpoint

  GET /info-batch (opens in a new tab)

  Per request

  up to 100 profiles

  On x.com logged out

  One profile per page load

Every post arrives with its author's full profile at no extra cost. A 403 answer means the key is missing or out of requests, and a 429 means more than 20 requests in one second: wait a second and retry. Failed requests are never charged. The two biggest jobs have their own walk-throughs: download all tweets from a user for an account's whole history, and export Twitter followers for follower lists.

Without code, the free Export Tweets from Twitter to CSV tool saves an account's posts or a search as CSV, Excel or JSON, and Export Twitter Followers to CSV does the same for follower lists. AI agents read the same data through the Sorsa MCP server, which our Twitter MCP server guide sets up in one command.

#Twitter scraper prices per 1,000 posts

Per 1,000 posts, the scraping tools that publish a price charge $0.15 to $1.50, the official X API charges $5.00, and Sorsa API starts at $0.07 by search and $0.014 by link or ID.

On every job these tools publish a price for, Sorsa API costs less per 1,000 posts, and it needs nothing but an API key:

• Sorsa API, posts by link or ID

  Per 1,000 posts

  from $0.014

  What it takes

  One API key; 100 posts per request

• Sorsa API, posts from a search

  Per 1,000 posts

  from $0.07

  What it takes

  One API key; about 20 posts per request

• Octoparse Twitter templates (opens in a new tab)

  Per 1,000 posts

  $0.30

  What it takes

  An Octoparse account; billed per row

• Apify Tweet Scraper V2 (opens in a new tab)

  Per 1,000 posts

  $0.40

  What it takes

  50 posts per query at least; no single posts

• Bright Data X scraper (opens in a new tab)

  Per 1,000 posts

  $1.50

  What it takes

  Post URLs as input; billed per record

• Official X API (opens in a new tab)

  Per 1,000 posts

  $5.00

  What it takes

  Developer account and OAuth; 3M post reads a month at most

• Official X API, post with its author

  Per 1,000 posts

  $15.00

  What it takes

  From November 22, 2026, per X's notice (opens in a new tab)

• Apify's Tweet Scraper V2 bills $0.40 per 1,000 tweets and needs at least 50 per query; Sorsa API returns search results from $0.07 per 1,000, with no minimum per query.
• Bright Data's X scraper bills $1.50 per 1,000 records collected from post URLs; Sorsa API looks up the same posts 100 per request, from $0.014 per 1,000.
• Octoparse's Twitter templates bill $0.30 per 1,000 rows; Sorsa API's search results start at $0.07 per 1,000 and arrive as JSON with the author in every post.

Good to know

From November 22, 2026, the official X API bills the author that comes back with each post as a $0.010 user read, so a post with its author costs $0.015 instead of $0.005. Budgets built on $5.00 per 1,000 posts triple for any job that needs authors.

For collecting posts every day, use Sorsa API: a million search results cost from $70, against $400 on Apify's Tweet Scraper V2 and $5,000 on the official X API, with no X account of yours involved. Third-party X data APIs that bill per call are priced side by side in our comparison of Twitter API alternatives. Pick a job and a size below to see the cost and the time at 20 requests per second:

#What a Twitter scraper costs beyond its price

A scraper's price per 1,000 leaves out what it takes to run: the X accounts it signs in with, the repairs after X changes its site, and the speed and shape of what it returns.

The X account it signs in with

Extensions and libraries that read search results or follower lists sign in as an X account, and heavy scraping can get that account blocked. Apify's blog (opens in a new tab) warns that a leaked session cookie lets anyone into the account without its password or 2FA, and Scweet's README (opens in a new tab) asks for a dedicated account, never a personal one. Sorsa API never asks for your X login or cookies, so the question never comes up.

Repairs after X changes its site

x.com loads its data through internal requests whose IDs X keeps rotating: the ID behind search changed 37 times between November 6, 2025 and October 31, 2026, about once every 10 days, by the snapshots of the TwitterInternalAPIDocument tracker. Every library and hosted tool built on its pages stops working after such a change until its maintainer catches up. The top Google result for "twitter scraper", a Chrome extension (opens in a new tab), has had no update since May 21, 2024.

Speed and the shape of the data

Page-rendering scraping APIs open one x.com page per request: in AIMultiple's October 2026 benchmark (opens in a new tab), four of them took 8 to 30 seconds per post, completed 91.1% to 99.6% of 1,000 requests, and returned HTML you parse with your own selectors. Sorsa API returns up to 100 posts per request as JSON at 20 requests per second, up to 2,000 posts a second.

What to ask before you pay

Six questions settle which route to trust with a scraping job, and Sorsa API answers each with a number:

• Does it need your X login or cookies?

  Sorsa API

  No: one API key in the ApiKey header

• What do 1,000 posts cost?

  Sorsa API

  From $0.014 by link or ID, from $0.07 by search

• Does it reach search and followers?

  Sorsa API

  Yes: search back to 2006, followers 200 per request

• What does it return?

  Sorsa API

  JSON, with the author's full profile in every post

• Is the response schema stable?

  Sorsa API

  Yes; your code stays the same

• How fast is it?

  Sorsa API

  20 requests per second on every plan, free included

#Collect your first 2,000 posts with one API key

Every Twitter scraper in 2026 trades something for its data: an X account, a wait for repairs, or $0.15 to $1.50 per 1,000 posts. For collecting public X data without that trade, use Sorsa API: one key, search results from $0.07 per 1,000, posts by link from $0.014, followers from $0.007, and 100 free requests that cover your first 2,000 posts.

#FAQ