How to Scrape Twitter Without API in 2026

To scrape Twitter without API access, use an Apify actor that wraps the X.com web interface and returns clean JSON — no developer account, no $200/month basic tier, no rate-limit headaches. The Cheap & Simple Twitter / X.com API charges $0.009375 per non-empty response and handles authentication, pagination, and flattening for you. This replaces broken tools like Twint (deprecated since Twitter killed legacy endpoints in 2023) and snscrape (blocked by the 2023 login wall).

Quick Answer

You can scrape Twitter without API access by running a third-party Apify actor that simulates browser requests to X.com and returns structured tweet data. Since X shut down free API tiers in February 2023 and blocked unauthenticated GraphQL calls, DIY scrapers like Twint and snscrape no longer work reliably. The practical replacement is a pay-per-event scraper that handles login sessions, cursor pagination, and retries server-side. Expect costs around $0.94 per 100 responses — roughly 50–100× cheaper than X's official $200/month Basic tier for comparable volume.

Why can't you use Twint or snscrape anymore?

Both are effectively dead. Twint's GitHub repo has been archived since March 2023 after Twitter removed the guest-token endpoints it relied on. snscrape stopped returning results in July 2023 when X enforced mandatory login for search and timeline endpoints.

What broke specifically:

• Guest tokens: X revoked anonymous read access to /i/api/2/search/adaptive.json
• RSS fallbacks: Nitter instances get rate-limited or banned within hours
• GraphQL without auth: Returns HTTP 401 on every endpoint since mid-2023

If you try to patch Twint or snscrape today, you'll spend 10–20 hours writing cookie rotation, header fingerprinting, and proxy logic — then re-do it in 6 weeks when X changes the frontend.

What are the current options to scrape Twitter in 2026?

Four realistic paths, ranked by effort:

The official API is cheapest per tweet if you only need 10k tweets/month — the Basic plan caps reads there. Above that threshold, the Pro tier jumps to $5,000/month, making third-party actors the only sane choice for most use cases.

How to scrape Twitter without API using Apify

Here's the end-to-end flow using the Cheap & Simple Twitter / X.com API:

1. Create an Apify account

Sign up at apify.com — free tier includes $5 in platform credits, enough for ~530 scraping responses.

2. Call the actor via API

curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "openai lang:en",
    "maxItems": 100,
    "sort": "Latest"
  }'

3. Get flattened JSON back

Each tweet returns as a flat object — no nested legacy.entities.user_mentions.indices nightmare:

{
  "id": "1789234567890",
  "text": "New model just dropped...",
  "createdAt": "2026-04-22T14:30:00Z",
  "authorUsername": "elonmusk",
  "authorFollowers": 185000000,
  "likes": 42000,
  "retweets": 8900,
  "replies": 3100,
  "lang": "en"
}

4. Paginate with cursors

The actor returns a nextCursor field. Pass it back in the next request to fetch the following page. Retries and session rotation happen automatically — you don't handle them.

How much does it cost to scrape Twitter without the API?

At $0.009375 per non-empty response, here's real-world pricing:

• 1,000 tweets: ~$0.94 (assuming 100 tweets per response batch)
• 10,000 tweets: ~$9.38
• 100,000 tweets: ~$93.75
• 1 million tweets: ~$937.50

Compare to X's official tiers:

• Basic ($200/mo): 10k tweet reads — $20 per 1k
• Pro ($5,000/mo): 1M tweet reads — $5 per 1k, but fixed monthly cost

The pay-per-event model wins decisively for bursty or exploratory workloads. If you scrape 50k tweets one week and 500 the next, you pay proportionally — no $200 minimum.

Is it legal to scrape Twitter without API access?

Scraping public tweets has been affirmed legal in the US under hiQ Labs v. LinkedIn (9th Circuit, 2022) and the Ninth Circuit's 2024 ruling on public data access. You are not bypassing authentication or accessing private accounts.

However:

• X's Terms of Service prohibit scraping. You cannot sign in to X and then scrape — that violates the TOS contract.
• Commercial republication of tweet content may trigger DMCA claims.
• EU GDPR applies if you store personal data (usernames, profile info) on EU residents.

Most researchers, SEO analysts, and trend-tracking teams operate in the gray zone safely by (a) scraping only public data, (b) not reselling raw tweet corpora, and (c) honoring deletion requests. Consult a lawyer for your specific use case.

Can you scrape Twitter user profiles and followers?

Yes. The same actor supports multiple endpoints:

• User lookup: username → full profile object (bio, followers, joined date, verified status)
• User tweets: Get last N tweets from any public account
• Followers / following lists: Paginate through connection graphs
• Search: Full-text search with X's advanced operators (from:, since:, min_faves:, etc.)
• Tweet replies: Fetch conversation threads by tweet ID

Example — scraping @naval's last 500 tweets:

{
  "userTweets": ["naval"],
  "maxItems": 500
}

Cost: ~5 responses × $0.009375 = $0.047.

How do you handle rate limits when scraping Twitter?

You don't — the actor does. X enforces aggressive limits (roughly 50 requests per 15 minutes for unauthenticated endpoints, more for logged sessions). A third-party scraper handles this through:

1. Session pool rotation: Multiple authenticated sessions cycle per request
2. Automatic backoff: 429 responses trigger exponential retry
3. Proxy rotation: Datacenter and residential IPs distribute load
4. Caching: Repeat queries within short windows return cached data

If you build your own scraper, expect to spend 60% of development time on rate-limit infrastructure. Using an actor offloads that entirely — you just hit the endpoint and get results.

What data fields can you extract?

Per tweet:

• Tweet ID, URL, text, language, created timestamp
• Author username, display name, follower count, verified status, profile image
• Engagement: likes, retweets, replies, quote count, views (when available)
• Media: image URLs, video URLs, alt text
• Conversation ID, in-reply-to user, quoted tweet reference
• Hashtags, mentions, cashtags, external URLs

Per user:

• ID, username, display name, bio, location, website
• Follower/following counts, tweet count, join date
• Verified, blue-checked, protected status
• Banner and profile image URLs

Fields arrive pre-flattened — no user.legacy.screen_name vs user.core.screen_name confusion from X's GraphQL schema changes.

FAQ

Q: Do I need a Twitter account or cookies to use the actor? No. The actor manages its own session pool server-side. You only need an Apify API token, which you get free at signup. This is a key reason to use a managed scraper instead of a self-hosted one.

Q: How fresh is the scraped data? Real-time. The actor hits X.com's live frontend — tweets posted 10 seconds ago appear in search results. There's no cached index or delayed feed, unlike some academic datasets that lag by hours or days.

Q: Can I scrape tweets from protected (private) accounts? No, and you shouldn't. Only publicly visible tweets are accessible. Scraping protected accounts would require bypassing authentication, which is both legally risky and technically outside the actor's scope.

Q: What happens if X changes its frontend and breaks the scraper? The actor is actively maintained — X typically ships breaking changes every 4–8 weeks, and fixes roll out within 24–72 hours. You pay $0 during downtime because pricing is per successful response, not per request.

Q: Can I use this for historical tweets from 2010? Yes, if the tweets are still publicly visible on X. Use the search endpoint with since:2010-01-01 until:2010-12-31 operators. X's search index goes back to 2006, though results beyond ~2015 can be incomplete for low-engagement accounts.