Download All Tweets From a User: 4 Methods (2026)

By Sorsa Editorial

Updated June 2026: refreshed the official X API costs under its pay-per-use model, re-verified the 3,200-tweet timeline cap against current docs, and added an Excel export plus a no-code path.

Every week a researcher, analyst, or developer hits the same wall: they need a complete tweet history from one account, and the platform makes it hard. The free archive only covers your own posts, most no-code tools stop at 3,200 tweets, and open-source scrapers break whenever X changes its frontend. Sorsa API, an alternative Twitter/X API, removes that ceiling. Its /user-tweets endpoint paginates a full timeline back to a user's first post, with one API key in a header and flat per-request pricing instead of the official API's per-resource billing. Pulling a 50,000-tweet account costs under $5 on the Pro plan and finishes in about two minutes.

We build and operate this API and test each of these methods against the live endpoints, so the tradeoffs below come from running them, not from guessing.

Want it done right now, without code? The Sorsa API Playground runs the /user-tweets endpoint against any public account from your browser with no key, and the free Twitter media downloader saves photos and video from individual tweets. For a repeatable or large export, the methods below scale further.

Table of Contents

• Method 1: Download your own Twitter/X archive
• Method 2: No-code browser export tools
• Method 3: Open-source scrapers
• Method 4: Use a Twitter/X data API
• How to download all tweets via API, step by step
• How do you get more than 3,200 tweets from a user?
• How much does it cost to download a full timeline?
• In practice: the accounts that break the other methods
• Frequently asked questions
• Getting started

Method 1: Download your own Twitter/X archive

X lets you download a complete archive of your own account for free. The export includes every tweet you have posted, your media, direct messages, and account metadata, with no tweet-count limit. It works only for an account you are logged into; you cannot request another user's archive.

To request it, open Settings and Privacy, then Your Account, then Download an archive of your data. Verify your identity, request the archive, and wait. X usually has it ready in 24 to 48 hours and emails a link to a .zip file. Inside is an HTML viewer plus a data/ folder of JSON files holding your full posting history and media.

The catch beyond the own-account limit is the format. The JSON is nested and Twitter-specific, not a clean spreadsheet, so turning it into something analyzable means writing a parser or running a conversion step.

Best for: personal backup, archiving your own account before deactivation, and compliance record-keeping.

Method 2: No-code browser export tools

Browser-based export tools let you download a public account's tweets to CSV or Excel without writing code. You enter a handle, wait, and download a file with tweet text, timestamps, and engagement metrics. Most of these tools run on the official X API underneath, so they inherit its 3,200-tweet ceiling and sometimes return fewer.

The category includes Circleboom, Tweet Binder, and a range of Chrome extensions. They differ mainly in output format and pricing, not in the underlying limit.

These tools are a reasonable pick when you need a quick export of recent tweets from a single account and do not want to touch code, and several of them output straight to Excel or PDF, which is convenient for non-technical stakeholders. The limit shows up on prolific accounts: ask one of these tools for the full history of an account with 50,000 posts and most will hand back the latest 3,200 at best. Paid plans also add up if you pull from many accounts regularly, and some tools ask you to connect your own session cookies, which carries its own security tradeoff.

Best for: one-off exports of recent tweets, non-technical users, quick competitive snapshots.

Method 3: Open-source scrapers

Open-source scrapers pull tweets by reverse-engineering X's web endpoints, bypassing the official API and its pricing. They are free, and they are fragile: when X rotates its frontend tokens, every scraper that depends on that mechanism breaks at once, with no SLA, no deprecation notice, and no migration path.

The landscape has also thinned. Tools that were standard a few years ago, snscrape and twint, are effectively dead, with snscrape untouched for years and twint archived. A handful of libraries are still maintained, but they carry the same structural risk: a working scraper today can stop working overnight after a single platform change. For a current view of what still runs, see our breakdown of Twitter scrapers in 2026 and the practical guide on how to scrape Twitter.

If you need repeatable access for a production workflow or research with a deadline, a scraper is a dependency you do not control.

Best for: ad-hoc exploration, budget-constrained projects with flexible timelines, developers comfortable fixing breakage.

Method 4: Use a Twitter/X data API

A data API is the most reliable way to download a full timeline programmatically: you send HTTP requests, receive structured JSON, and paginate until you reach the account's first tweet. The official X API works but caps the user timeline at 3,200 posts and bills per resource under its 2026 pay-per-use model, while a third-party data API can return the complete history at a flat per-request rate.

The official X API

Two things make the official path painful for this specific job. First, the user timeline endpoint is capped at the 3,200 most recent posts, a documented limit that has held for over a decade and still applies on X API v2. Second, the current pay-per-use model bills per resource read (roughly $0.005 per post and $0.010 per user profile), with a 2-million-post monthly cap, so large collections get expensive fast even before you hit the timeline ceiling. Authentication is OAuth 2.0 with a bearer token rather than a single key.

Third-party data APIs

Third-party APIs reach the same public data with simpler authentication, more predictable pricing, and fewer restrictions. Sorsa is one such alternative Twitter/X API: a managed REST service that returns full tweet data from a single ApiKey header, charges a flat rate per request rather than per resource, and crucially has no 3,200-tweet cap on its /user-tweets endpoint. You paginate a user's entire history until you reach their first post. For how the pricing models compare in detail, see our 2026 Twitter API pricing breakdown.

Best for: developers, data engineers, production pipelines, research projects, anyone who needs structured data at scale.

How to download all tweets via API, step by step

This walks through the full process with Sorsa API, from the first request to a finished file.

Prerequisites

• An API key from the Sorsa dashboard (Starter plan or above)
• Python 3.7+ with the requests library, or Node.js 18+
• The target account's username, for example stripe

New to the API? The quickstart guide covers authentication and your first request in a few minutes, and the Twitter API Python guide goes deeper on the client setup used below.

Fetch the complete timeline

The /user-tweets endpoint returns about 20 tweets per page with cursor-based pagination. Loop through pages until next_cursor is absent or null, which means you have reached the end of the timeline.

Python:

import requests
import time

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sorsa.io/v3"

def download_all_tweets(username, max_pages=None):
    """Download every tweet from a public account."""
    all_tweets = []
    cursor = None
    page = 0

    while True:
        body = {"username": username}
        if cursor:
            body["next_cursor"] = cursor

        resp = requests.post(
            f"{BASE_URL}/user-tweets",
            headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
            json=body,
        )
        resp.raise_for_status()
        data = resp.json()

        tweets = data.get("tweets", [])
        all_tweets.extend(tweets)
        page += 1
        print(f"Page {page}: {len(tweets)} tweets (total: {len(all_tweets)})")

        cursor = data.get("next_cursor")
        if not cursor:
            print("Done. Reached end of timeline.")
            break
        if max_pages and page >= max_pages:
            print(f"Stopped at {max_pages} pages.")
            break

        time.sleep(0.05)  # stay well within 20 requests per second

    return all_tweets


tweets = download_all_tweets("stripe")
print(f"\nCollected {len(tweets)} tweets from @stripe")

JavaScript:

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sorsa.io/v3";

async function downloadAllTweets(username, maxPages = Infinity) {
  const allTweets = [];
  let cursor = null;
  let page = 0;

  while (page < maxPages) {
    const body = { username };
    if (cursor) body.next_cursor = cursor;

    const resp = await fetch(`${BASE_URL}/user-tweets`, {
      method: "POST",
      headers: {
        "ApiKey": API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);

    const data = await resp.json();
    allTweets.push(...(data.tweets || []));
    page++;

    console.log(`Page ${page}: ${data.tweets?.length || 0} tweets (total: ${allTweets.length})`);

    cursor = data.next_cursor;
    if (!cursor) break;
    await new Promise((r) => setTimeout(r, 50));
  }

  return allTweets;
}

const tweets = await downloadAllTweets("stripe");
console.log(`Collected ${tweets.length} tweets from @stripe`);

Each tweet object carries the full text, publication date, engagement counts (likes, retweets, replies, quotes, views, bookmarks), language, media entities, and the complete author profile. That author profile is embedded in every response at no extra request cost, so you do not need a separate call to fetch the account unless you specifically want its bio links or pinned tweet IDs first.

Export to CSV

Once you have the tweets, write them to CSV for analysis in Pandas, R, Google Sheets, or a database import:

import csv

def export_tweets_csv(tweets, filename="tweets.csv"):
    fields = [
        "id", "created_at", "full_text", "lang",
        "likes_count", "retweet_count", "reply_count",
        "quote_count", "view_count", "bookmark_count",
        "is_reply", "is_quote_status", "username",
    ]

    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        for t in tweets:
            writer.writerow({
                "id": t["id"],
                "created_at": t["created_at"],
                "full_text": t["full_text"].replace("\n", " "),
                "lang": t.get("lang", ""),
                "likes_count": t.get("likes_count", 0),
                "retweet_count": t.get("retweet_count", 0),
                "reply_count": t.get("reply_count", 0),
                "quote_count": t.get("quote_count", 0),
                "view_count": t.get("view_count", 0),
                "bookmark_count": t.get("bookmark_count", 0),
                "is_reply": t.get("is_reply", False),
                "is_quote_status": t.get("is_quote_status", False),
                "username": t.get("user", {}).get("username", ""),
            })

    print(f"Exported {len(tweets)} tweets to {filename}")


export_tweets_csv(tweets, "stripe_tweets.csv")

Export to Excel

If the audience is non-technical and wants a spreadsheet, write the same rows to .xlsx with Pandas in two lines:

import pandas as pd

df = pd.DataFrame(tweets)
df.to_excel("stripe_tweets.xlsx", index=False)

If the destination is a shared spreadsheet rather than a local file, our guide on exporting Twitter data to Google Sheets covers the no-code route. For a shareable report rather than a working dataset, you can render the table to PDF with a library like ReportLab, but CSV and JSON stay the better choices when the data is going into analysis or a model.

Going beyond the timeline: the search method

The /user-tweets endpoint gives you the raw chronological timeline. When you want a targeted slice instead, only tweets with images, only tweets above a like threshold, or a specific date range, use /search-tweets with the from: operator:

# High-engagement tweets from one account
resp = requests.post(
    f"{BASE_URL}/search-tweets",
    headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
    json={"query": "from:stripe min_faves:50 -filter:replies", "order": "latest"},
)

You can combine from: with engagement filters (min_faves:, min_retweets:), media filters (filter:images), language codes (lang:en), and date ranges (since: / until:). The Search Builder assembles these queries visually, and the full search operators reference lists every option. For pulling tweets across many accounts by keyword and date rather than one timeline, that is archive search; our guide on historical Twitter data covers that workflow in full.

How do you get more than 3,200 tweets from a user?

To get more than 3,200 tweets from a user, you cannot rely on the official X API's timeline endpoint, which hard-caps at the 3,200 most recent posts (and at 800 when replies are excluded). The two working routes are a paginated third-party data API that walks the full timeline, or search-based collection across date ranges. Scraping the web search page day by day also works but breaks often and is slow.

This 3,200 ceiling trips up far more people than the pricing does. Older guides and forum answers still claim getting past it is impossible, or point to Selenium scripts that scrape Twitter's search page one day at a time. Those scripts were built for a search interface that has since changed and mostly no longer run. Here is how each method actually stacks up today:

For most casual needs, pulling the last few hundred tweets for a content audit, the 3,200 limit never bites. It becomes a dealbreaker for researchers archiving political commentary, analysts building historical engagement datasets, and anyone working with prolific accounts: journalists, politicians, and media brands routinely sit well past 50,000 posts. If you need to go deeper than a single timeline, our historical data guide covers date-windowed collection.

How much does it cost to download a full timeline?

Downloading a full timeline through a flat-rate data API is cheap. At roughly 20 tweets per request, a 50,000-tweet account is about 2,500 requests; on a plan priced near $0.002 per request that is under $5, and it finishes in about two minutes at 20 requests per second. The cost scales linearly with account size, not with how the data is billed per resource.

Here is what full extraction looks like on Sorsa at different scales, on the Pro plan at $0.00199 per request:

The full timeline of a 50,000-tweet account costs under $5 and takes about two minutes. A no-code tool charging a monthly subscription would still hand you only the latest 3,200 from that same account. If you pull from many accounts on a schedule, the Pro plan at 100,000 requests covers roughly 40 full 50,000-tweet archives a month, and our notes on reducing unnecessary API calls help stretch that further.

In practice: the accounts that break the other methods

The accounts people most often need in full are the prolific ones, which is exactly where the other methods fail. A media-monitoring team we worked with needed the complete posting history of a public figure with around 60,000 tweets for a discourse study. Their existing no-code tool returned the most recent 3,200 and stopped, leaving a multi-year gap they could not fill. They switched to paginating the /user-tweets endpoint, pulled the entire timeline in a single afternoon for under $6 on the Pro plan, and wrote it straight to CSV for their model. The 3,200 ceiling, not the cost, had been the real blocker all along, and once it was gone the job was routine. The same collect-then-export pattern underpins our walkthrough on building a Twitter dataset for machine learning.

Frequently asked questions

Can you download tweets from a private (protected) account?

No. Protected accounts restrict their tweets to approved followers, so no API, scraper, or export tool can read them unless you are an authenticated follower with an active session. This applies equally to the official X API, Sorsa API, and every other method here. Only public accounts can be downloaded by a third party.

How far back can you go?

The official X API's timeline endpoint returns only the 3,200 most recent tweets regardless of their age. Your own Twitter archive contains everything you have posted. A paginated data API such as Sorsa API walks the /user-tweets timeline back to a user's first post with no hard limit, and search by from:username with since: and until: operators gives precise control over a specific window.

Do downloaded tweets include images and videos?

Yes. Each tweet object contains an entities array with direct URLs for photos, videos, and GIFs attached to the tweet, plus preview thumbnails. You can use those URLs to download the media files programmatically. For a no-code way to save media from individual tweets, the free Sorsa media downloader handles photos, video, and audio, and the guide on downloading Twitter media via API covers the programmatic version.

Is it legal to download someone's tweets?

Downloading publicly available tweets for personal analysis, research, or business intelligence is generally permissible, since public tweets are visible to anyone online. How you use the data is what carries risk: redistribution, republishing at scale, or using it to harass can violate platform terms or regulations such as GDPR in the EU. For large-scale or commercial collection, consult legal counsel familiar with your jurisdiction.

What format is best for analysis, CSV, JSON, or Excel?

CSV is the most universal choice and opens in Excel, Google Sheets, Pandas, and R. JSON preserves the full nested structure, such as media entities, quoted tweets, and author objects, and suits programmatic processing or database imports. Excel is convenient for non-technical stakeholders but adds a conversion step. Start with CSV; reach for JSON when you need nested reply or media data.

Is there a Twitter API without the 3,200-tweet limit?

Yes. Sorsa API is a Twitter/X data API whose /user-tweets endpoint has no 3,200-tweet cap: you paginate a complete timeline back to the account's first post. It authenticates with a single ApiKey header instead of OAuth, bills a flat rate per request rather than per resource, and applies a 20 requests-per-second limit on every plan, so a full archive of a large account costs only a few dollars.

How do you download tweets containing specific keywords or hashtags?

Use search instead of the timeline endpoint. Pass a query combining the keyword or hashtag with a from:username filter to /search-tweets. For example, from:stripe #payments since:2025-01-01 returns only tweets from @stripe containing the #payments hashtag posted since January 2025. The complete operator list lives in the search operators reference.

Getting started

To try the /user-tweets endpoint before writing any code, the Sorsa API Playground runs requests against any public account in your browser with no key required. When you are ready to build, grab a key from the dashboard and follow the quickstart: no approval process, no OAuth flow, a single API key, and a flat 20 requests per second on every plan. The Starter plan at $49 for 10,000 requests is enough to fully archive most accounts, and you can scale up from there.

Reviewed by Keksich, founder of Sorsa, marketer and X API researcher.

This guide draws on our own work running an alternative Twitter/X API since 2022, now past 5 billion requests served, and on testing all four of these methods against the live endpoints. We re-verified the 3,200-tweet timeline cap in June 2026 against the current X API v2 documentation and the tweepy client reference, and the official X API pay-per-use rates against X's published developer pricing. Endpoint behavior, pagination, and per-request costs are taken from the Sorsa API documentation and our 2026 pricing breakdown; more about the team is on our about page. Spot something out of date? Reach us at contacts@sorsa.io. Last verified June 6, 2026.