Here is a problem nobody warns you about until you hit it. You finally export your X bookmarks, you open the file, and half of it is useless. Not because the export failed. Because every thread you saved came out as a single orphaned tweet. The hook with no payoff. The setup with no punchline. The “1/12” with no 2 through 12.
This is not a bug in the tool you used. It is baked into how X bookmarks work. When you tap the ribbon on a thread, you do not save the thread. You save one tweet. The export tool is just faithfully copying what you actually bookmarked, which was never the whole conversation in the first place.
So if you are exporting your bookmarks to back them up or move them somewhere useful, you have a second problem layered on top of the first. You have to get the data out of X, and you have to keep the threads intact while you do it. Most guides only cover the first half. This one covers both.
- A bookmark is one tweet, not a thread. Standard exporters copy only the tweet you saved, so threads come out as orphaned fragments.
- X has no export at all. The official data archive does not include bookmarks, confirmed for years.
- CSV exports store links, not content. When the author deletes the thread, your export breaks too.
- To keep threads, capture the content. Unroll each one to PDF, or use a tool that saves the full chain at bookmark time.
- ContextBolt stores your saves locally so a deleted thread doesn’t wipe your copy, and still exports to CSV.
Why a bookmark only saves one tweet
Start with the thing that causes all of this. A bookmark on X is a pointer. When you tap the ribbon, X stores a reference to that one post ID. Nothing else. Not the tweet above it that started the thread, not the eleven replies below it that finished the point.
A thread is just a chain of separate tweets from the same author, linked by reply. The platform treats each one as its own object. So when you bookmark “the good one,” you save a single link in the middle of a conversation. The rest is still on X, you just have to scroll to find it, and nothing in your bookmark list knows the rest exists.
This matters the second you try to export. An exporter reads your bookmark list and copies what it finds. What it finds is a list of single tweets. There is no thread data in there to export, because you never bookmarked a thread. You bookmarked a tweet that happened to live inside one.
That is why the file looks broken. It is doing exactly what you asked. The gap is upstream, in what a bookmark is.
X still has no export button
Before fixing the thread problem, deal with the fact that X gives you nothing to start from.
There is no export feature for bookmarks. Not in the app, not in Settings, not anywhere in the product. The one place people expect to find them is the official data archive download, the one that hands you your tweets, DMs, likes, and account history. Bookmarks are not in it. They never have been. The gap is documented in X’s own developer forums and has gone unfixed for years.
So every method below is a third-party workaround. You are not choosing between an official export and a tool. You are choosing between tools, full stop. The only real decision is which one keeps your threads whole. For the broader rundown of every export route regardless of threads, the export X bookmarks guide walks through all four.
What standard exporters do to your threads
Most “export your bookmarks” tools fall into two buckets, and both lose threads in the same way.
One-click CSV extensions. You install a Chrome extension, open your bookmarks page, scroll, and it dumps everything to a spreadsheet. Fast and free. But each row is one tweet: the text, the author, the date, maybe the engagement numbers. The thread the tweet belonged to is not a column, because the extension only ever saw the single bookmarked post. You get 500 rows and 500 fragments.
Open-source userscripts. The strongest free option is twitter-web-exporter, which reads directly off the rendered page and bypasses the 800-bookmark API cap. It is excellent at volume. It still exports the bookmarked tweet, not the chain, because the chain was never in your bookmarks to begin with.
There is a deeper trap with both. They export the link, or the text as it existed at export time, with no living copy of the conversation. If the author later deletes the thread, your CSV row points at nothing. We covered this failure mode in detail in why social bookmarks disappear, and threads are the worst-hit case, because a single deleted tweet in the middle can gut the whole point.
So the honest summary of the standard path is this. You can get your bookmarks out. You cannot get your threads out, and what you do get is fragile.
Three ways to actually keep the threads
If the thread is the thing you cared about, you need a method that captures the conversation, not just the bookmark. Three work in 2026.
Method 1: Unroll, then print to PDF
The manual but reliable route. Take any tweet in the thread, paste its URL into Thread Reader App, and it stitches the whole chain into one scrollable page. Then use your browser’s Print to PDF on that unrolled page. You now own a frozen copy of the entire thread that survives the author deleting it.
This is genuinely good for your handful of all-time-best threads. It falls apart at scale. Unrolling and printing 300 threads by hand is an afternoon you will not get back, and you end up with 300 PDF files and no way to search across them. For a deeper comparison of unrollers, see the best Twitter thread unroller breakdown.
Method 2: A bookmark manager with full-thread capture
Some dedicated managers capture the full thread, not just the bookmarked tweet. Dewey does this, walking the chain from the tweet you saved and pulling the surrounding posts into one entry, then exporting to CSV, PDF, or Google Sheets. The upside is you get thread-aware export without the manual unrolling. The trade-off is a subscription and your data passing through a third-party server.
Method 3: Capture the content at save time
The cleanest fix is to stop treating “save” and “export” as two separate jobs. If a tool grabs the actual content of what you bookmark the moment you save it, the export is just a download of data you already own. Nothing to scrape later, nothing to break when the original disappears. This is the model worth aiming for, and it is how ContextBolt works, covered below.
Export methods compared for threads
| Method | Keeps full thread? | Survives deletion? | Format | Cost |
|---|---|---|---|---|
| X data archive | No (no bookmarks at all) | N/A | HTML, JSON | Free |
| One-click CSV extension | No (first tweet only) | No | CSV, JSON | Free |
| twitter-web-exporter | No (bookmarked tweet only) | No | CSV, JSON, HTML | Free |
| ThreadReader + Print to PDF | Yes (one at a time, manual) | Yes (PDF copy) | Free / paid | |
| Dewey | Yes (full-thread capture) | Yes | CSV, PDF, Sheets | ~$5/month |
| ContextBolt | Captures saved content | Yes (local copy) | Searchable library + CSV | Free / $6/month |
The question hiding under “export”
Here is the part worth saying out loud, because it is the whole reason most people are reading this.
You do not actually want a file. Nobody opens a CSV of 500 tweets twice. What you want is to find the thread again. The export is a proxy for that, a way of saying “let me keep this somewhere I can get back to it.” And a flat file, with the threads already stripped out, is the worst possible place to keep it. You exported to feel safe, and you ended up with fragments you will never read.
This is why the deletion problem and the thread problem are really the same problem wearing two hats. Both come from saving a link instead of the content. Fix that, and export stops being a panicky backup and becomes a non-event, because the data already lives somewhere you control.
That is the thing I built ContextBolt to do. It is a Chrome extension that captures your X bookmarks (plus your Reddit and LinkedIn saves) into a library that lives on your machine. It stores the content of what you saved, so when an author nukes their thread, your copy is still there. It auto-tags every save by topic, so your bookmarks organize themselves. And it lets you search by meaning instead of guessing the one keyword the opening tweet used, which is the actual way you remember a thread later. That side is covered in semantic search for bookmarks, and the full thread-capture detail is in the save Twitter threads guide. Basic is free for 150 saves. Pro at $6/month lifts that to unlimited, adds encrypted cloud sync, and gives you an MCP endpoint so tools like Claude can read your saved threads directly. And if you still want a plain file, it exports to CSV in one click.
Which method should you use?
If you have a few all-time-great threads: Unroll each one with Thread Reader and print to PDF. Slow, manual, but you own a permanent frozen copy and it costs nothing.
If you want thread-aware export as a feature among many: Dewey captures the full chain and exports to clean formats. Pay the subscription if managed export is what you are after.
If the real goal is to find your threads again, not file them away: Use a tool that captures content at save time so export is just a download. That is the model that fixes both the thread problem and the deletion problem at once. If you work inside Claude, Cursor, or Windsurf, the MCP endpoint makes your saved threads searchable from your AI tools without exporting anything.
Export is a workaround for a platform that does not respect your data. The threads getting mangled on the way out is that disrespect made visible. The long-term fix is not a better exporter. It is keeping your saves somewhere that stored the whole thing in the first place.