How to Save Twitter Threads (2026 Guide)

Some Twitter threads carry more value than most blog posts. A developer's 20-tweet breakdown of system design, a researcher's analysis of a news event, a writer's essay told in fragments. These are the posts you don't want to lose to the feed.

The problem? Twitter's timeline moves fast. Threads get buried, accounts get suspended, and content disappears. If you don't save something when you see it, there's a good chance you'll never find it again.

This guide covers every practical way to save Twitter/X threads from the built-in bookmark feature to full programmatic capture using ScreenshotAPI.net.

Why People Save Twitter Threads

People save threads for all kinds of reasons:

• Research and documentation: journalists, analysts, and academics archiving primary sources
• Offline reading: catching up on content without an internet connection
• Content repurposing: turning threads into blog posts, newsletters, or reports
• Evidence preservation: saving content before it's deleted or edited
• Personal knowledge management: building a library of useful ideas and resources
• Business monitoring: tracking what competitors or industry voices are saying

Whatever the reason, the default Twitter/X experience doesn't make any of this easy.

Common Ways to Save Twitter Threads

1. Twitter/X Bookmarks

The simplest option. Hit the Share icon on any tweet in the thread and tap Add to Bookmarks. You can access saved bookmarks from the left sidebar (desktop) or profile menu (mobile).

Limitation: Bookmarks are online-only. If the account is deleted or the tweet is removed, the bookmark breaks. There's also no way to organize bookmarks into folders on the free plan.

2. Manual Screenshots

A quick screenshot works for a single tweet. For a full thread, you'd need to scroll and capture each tweet individually, which gets tedious fast, especially for long threads.

Limitation: Images aren't searchable. No text is preserved. Managing dozens of screenshot files quickly becomes its own organizational problem.

3. Copy and Paste into Notes

Some people copy thread text and paste it into Notion, Apple Notes, or Google Docs. Workable for short threads, but for longer ones, you're doing a lot of manual work with no image context preserved.

4. Save as PDF via Browser

On a desktop, you can open a thread, use Ctrl+P (or Cmd+P on Mac), and choose Save as PDF. This captures the visible page, but Twitter's layout often breaks across pages and doesn't capture the full thread in one go.

Problems with Manual Methods

Each manual method has trade-offs. The comparison below shows where each one breaks down.

If you're saving one thread occasionally, any of these might be fine. But if you need to archive threads at scale for a research project, content pipeline, or monitoring workflow, you need something that can be automated.

How to Save Twitter Threads Using ScreenshotAPI.net

ScreenshotAPI.net is a web screenshot service API that captures any public URL as a full-page PNG, JPEG, WebP, or PDF. Because Twitter/X threads are just web pages, ScreenshotAPI can capture the entire visible thread as a high-resolution image or document programmatically, on demand.

This approach is particularly useful for:

• Automated archiving: capture threads on a schedule or trigger
• Research pipelines: batch-save threads as part of a data collection workflow
• Compliance and documentation: preserve timestamped visual records
• Content teams: save threads for repurposing without manual work
• Monitoring: log screenshots of threads for later comparison

What Makes ScreenshotAPI Good for This

• Outputs PNG, JPEG, WebP, or PDF
• Supports full page screenshot, not just the visible viewport
• Simple GET or POST API, easy to integrate into any stack
• Handles JavaScript-heavy pages like Twitter/X
• Returns a direct image URL or extracted text data
• Supports proxy, CSS & JavaScript injection, delay, and more

Step-by-Step Tutorial

Step 1: Get Your API Key

Sign up at screenshotapi.net and grab your API token from the dashboard.

Step 2: Find the Thread URL

Go to Twitter/X and open the first tweet of the thread you want to save. Copy the URL from the address bar. It will look something like:

https://twitter.com/username/status/1234567890123456789

Or on X.com:

https://x.com/username/status/1234567890123456789

Step 3: Make Your API Request

The core API endpoint is:

https://shot.screenshotapi.net/screenshot

You pass the thread URL as the url parameter, along with your token and output preferences.

Key parameters:

Step 4: Code Examples

cURL

curl --location 'https://shot.screenshotapi.net/v3/screenshot?token={YOUR_API_KEY}&url=https://x.com/username/status/1234567890123456789&output=json&file_type=jpg&full_page=true&fresh=true&width=1280'

JavaScript (Node.js)

const fs = require("fs");
const request = require("request");

const token = "YOUR_API_KEY";
const threadUrl = encodeURIComponent(
  "https://x.com/username/status/1234567890123456789"
);

const query =
  `https://shot.screenshotapi.net/v3/screenshot` +
  `?token=${token}` +
  `&url=${threadUrl}` +
  `&output=image` +
  `&file_type=jpg` +
  `&full_page=true` +
  `&fresh=true` +
  `&width=1280`;

request.get({ url: query, encoding: "binary" }, (err, response, body) => {
  if (err) {
    console.error("Error capturing thread:", err);
    return;
  }
  fs.writeFile("twitter_thread.jpg", body, "binary", (err) => {
    if (err) console.error(err);
    else console.log("Thread saved as twitter_thread.jpg");
  });
});

Python (requests)

import requests

token = "YOUR_API_KEY"
thread_url = "https://x.com/username/status/1234567890123456789"

params = {
    "token": token,
    "url": thread_url,
    "output": "image",
    "file_type": "jpg",
    "full_page": "true",
    "fresh": "true",
    "width": 1280,
}

response = requests.get("https://shot.screenshotapi.net/v3/screenshot", params=params)
response.raise_for_status()

with open("twitter_thread.jpg", "wb") as f:
    f.write(response.content)

print("Thread saved as twitter_thread.jpg")

Step 5: Example JSON Response

If you use output=json instead of output=image, ScreenshotAPI returns metadata alongside the screenshot URL:

{
    "screenshot": "https://s3.eu-central-2.wasabisys.com/w.storage.screenshotapi.net/x_com_d69c2186407c.jpeg",
    "url": "https://x.com",
    "created_at": "2026-05-14T07:00:20.751Z",
    "token": "FDRNXFR-M604XAN-NBRWAW0-6JFFD8X",
    "file_type": "jpg",
    "full_page": "true",
    "fresh": "true",
    "width": "1280",
    "ttl": "2026-06-13T07:00:16.668Z",
    "sizes": null
}

You can then download or store the screenshot URL wherever you need it, in a database, S3 bucket, or Notion embed.

Take Screenshots of Protected Pages (Login-Walled Threads)

Some Twitter/X content is only visible when you're logged in, such as age-restricted threads, private accounts you follow, or any page that greets you with a login prompt before showing content. A standard API call won't get past that wall.

ScreenshotAPI solves this with Cookies Templates. You export your active browser session cookies once, save them in the dashboard, and the API reuses them on every request, no login forms, no token exchanges, no repeated manual setup.

Once your Cookies Template is saved, pass its ID as the template_id parameter on any request:

curl --location 'https://shot.screenshotapi.net/v3/screenshot?token=YOUR_API_KEY&url=https://x.com/username/status/1234567890123456789&output=image&file_type=jpg&full_page=true&template_id=YOUR_TEMPLATE_ID&width=1280'

The API attaches your saved cookies to the underlying browser session before rendering the page, so login-walled threads load as if you were signed in.

A Few Things to Keep in Mind

• Cookie security: ScreenshotAPI encrypts all stored cookie data at rest. Only your API key can access your templates.
• Cookie expiry: Twitter/X session cookies eventually expire. If captures start failing, re-export your cookies and update the template.
• One template, many requests: You only need to create the cookie template once. Reuse the same template_id across all your requests.

Workflow Patterns That Work Well

Three integration patterns come up most often in production setups. Each builds on the basic API call from Step 4, with a different layer wrapped around it.

Scheduled capture via workflow tools

Connect the ScreenshotAPI endpoint to a Zapier, Make, or n8n scheduled job. The trigger watches a Twitter list, an RSS-equivalent feed, or a Google Sheet of thread URLs. Each new entry fires a single API call, and the returned screenshot URL is dropped into a downstream action: an Airtable row, a Notion database, or an S3 bucket. Most non-engineering teams can run this end-to-end without writing code.

Real-time team notifications

Wrap the API call inside a Slack or Discord webhook handler. When someone shares a thread URL in a designated channel, the handler captures the page and posts the screenshot back into the thread along with the source URL and a timestamp. Useful for incident response, competitor monitoring, and editorial review queues where the screenshot needs to live where the conversation is happening.

Persistent archive with metadata

For long-term storage, pair each call with a database write. Store the screenshot URL alongside the original tweet URL, the capture timestamp, the author handle, and any tags relevant to your workflow. A simple Postgres table or a Notion database works well. This pattern is the foundation for searchable internal libraries and any setup where the screenshot will be referenced months or years later.

Conclusion

Manual methods work, but only up to a point. Bookmarks disappear when accounts do. Screenshots miss context. Browser PDFs are messy. For anyone who needs reliable, scalable, and automated thread archiving, ScreenshotAPI.net offers a clean programmatic solution to capture any public Twitter/X thread as a full page screenshot or PDF with a single API call.

The right method depends on volume. For occasional saves, native bookmarks or browser PDF are usually enough. Once thread archiving becomes part of a recurring workflow (research, monitoring, content production), switching to a single API call removes the friction that makes manual methods break down at scale.

Frequently Asked Questions

Can I save a Twitter thread without logging in?

Yes. Public threads are captured directly from the rendered public-facing page, so no Twitter/X login is required for the API call. If the thread or any tweet inside it is on a protected account, age-gated, or behind a login wall, you'll need a Cookies Template with your own session cookies to capture it.

What's the best format to save a Twitter thread - PNG or PDF?

Depends on what you're doing with it. PNG and JPEG work well for visual snapshots you'll share or embed, with JPEG being smaller in file size. PDF is the stronger choice for archiving long threads because it preserves continuous scroll and is easier to open across devices without a separate image viewer.

Will the saved screenshot break if the original tweet is deleted?

No. Once the screenshot or PDF is generated, the file lives independently of the source tweet. It remains intact even if the tweet is deleted, the account is suspended, or the platform restructures its URLs. This permanence is the main advantage over Twitter's native bookmarks, which break the moment the underlying content goes away.

Can I automate saving multiple threads at once?

Yes. You can loop over a list of thread URLs in any scripting language and call the API for each one. For batch jobs of several hundred or more, use the asynchronous endpoint or space requests with a short delay to stay inside your plan's rate limits. Many teams schedule these jobs with cron or a workflow tool like Zapier.