Pocket Export HTML Converter: Convert ril_export.html to CSV, JSON & Markdown

You exported your Pocket data before the shutdown. Good. Now you have a file called ril_export.html sitting in your Downloads folder and no obvious way to do anything with it. It opens in a browser as a wall of links. You can't import it into a spreadsheet. You can't search it. You can't share it with another app without a conversion step first.

This guide covers three ways to convert your Pocket HTML export to something useful — CSV, JSON, Markdown, or a direct import to a new read-later app — ordered from least to most technical.

What is the Pocket HTML export file?

When Pocket was alive, you could request your full reading history at getpocket.com/export. The file you received was named ril_export.html — RIL stands for Read It Later, the original name before Mozilla acquired Pocket in 2017.

The file format is simple HTML: a <ul> list of <li> items, each containing an anchor tag with four data attributes: the URL, the title, a Unix timestamp for when you saved it, and tags if you added any. There are two sections: "Unread List" (articles you never opened) and "Read Archive" (articles you finished). The whole thing is a flat file — no database, no server required to read it.

The problem is that this format is not natively importable anywhere except a small number of apps that built specific Pocket parsers. Everything else needs you to transform it first.

Why you want to convert it: three use cases

The Pocket HTML file is an archive, not a tool. Until you convert it, it does one thing: opens in a browser as a clickable list. Here are the three most common reasons people need a conversion:

• •Migration — you want to bring your Pocket history into a new read-later app (Raindrop, Instapaper, Burn 451, Readwise Reader). Most apps accept CSV or JSON import, not raw HTML.
• •Analysis— you want to see what you actually saved: how many articles per domain, what tags you used most, how much of your reading list you never opened. The HTML file can't be filtered or sorted without converting to CSV first.
• •Archive — you want to keep your reading history in a format you can search and query in 10 years. CSV in Google Drive or JSON in a personal database outlasts any single app.

"I have a 50MB pocket HTML file and no idea what to do with it."

That's a real situation — 10,000+ saves across years of reading accumulates fast. A 50MB file is about 40,000 to 60,000 articles depending on title length and tag density. The approaches below handle this size without issues. The Python script processes a 100MB file in under 5 seconds on a modern laptop with no file size limit.

The good news: once you have the file, none of the conversion steps require a Pocket account or internet connection. The file contains all the data you need.

Option 1: Python script — 5-line BeautifulSoup converter

If you have Python 3 installed, this is the most flexible approach. You get full control over the output format, no file size limits, and the ability to customize fields.

Install BeautifulSoup if you don't have it:

pip install beautifulsoup4

The converter script (CSV output):

from bs4 import BeautifulSoup
import csv, datetime

with open("ril_export.html", "r", encoding="utf-8") as f:
    soup = BeautifulSoup(f, "html.parser")

with open("pocket_export.csv", "w", newline="", encoding="utf-8") as out:
    writer = csv.writer(out)
    writer.writerow(["url", "title", "time_added", "tags", "status"])
    for a in soup.find_all("a"):
        ts = int(a.get("time_added", 0))
        date = datetime.datetime.fromtimestamp(ts).strftime("%Y-%m-%d") if ts else ""
        writer.writerow([
            a.get("href", ""),
            a.get_text(strip=True),
            date,
            a.get("tags", ""),
            "read" if a.get("time_read") else "unread",
        ])

Run it with python convert_pocket.py in the same directory as your ril_export.html file. You'll get pocket_export.csv with all your saved URLs.

For JSON output, replace the CSV writer section with:

import json
items = []
for a in soup.find_all("a"):
    ts = int(a.get("time_added", 0))
    items.append({
        "url": a.get("href", ""),
        "title": a.get_text(strip=True),
        "time_added": datetime.datetime.fromtimestamp(ts).isoformat() if ts else None,
        "tags": a.get("tags", "").split(",") if a.get("tags") else [],
        "status": "read" if a.get("time_read") else "unread",
    })
with open("pocket_export.json", "w", encoding="utf-8") as f:
    json.dump(items, f, indent=2, ensure_ascii=False)

For Obsidian-compatible Markdown with YAML frontmatter, each article becomes a separate .md file. The GitHub Gist linked at the end of this post has that variant.

The script approach is the right choice if you have a file over 50MB, need a custom output schema, want to filter by date or tag before exporting, or are building an automated pipeline. Everything is in plain Python with no exotic dependencies.

Option 2: Raindrop.io direct HTML import (no conversion needed)

If your destination is Raindrop.io, skip the conversion step entirely. Raindrop is the only major bookmark app that built a native Pocket HTML importer.

Steps:

1. 1.Create a Raindrop.io account (free tier is fine for migration)
2. 2.Go to Settings → Import → "Pocket"
3. 3.Upload your ril_export.html file
4. 4.Raindrop creates a collection called "Pocket" with your saved links, tags intact

This is the lowest-friction path for bulk archive preservation. Raindrop's free tier handles the import, and you can browse, search, and filter your Pocket history from any device. The tradeoff: Raindrop is more of a bookmark organizer than a read-later app — it doesn't have a reading mode or pressure to actually read what you save.

For a comparison of read-later behavior across apps, see: Pocket replacement 2026 — what to do after the shutdown.

Option 3: Notion via Pocket integration export

This option only applies if you had the Pocket–Notion integration active before the Pocket shutdown (July 8, 2025). If you did, your saves were synced to a Notion database in real-time. That database still exists in your Notion workspace even though Pocket is gone.

If you find a Notion database called "Pocket" or "Saved Articles" in your workspace, you can:

• •Export it as CSV from Notion (Database → … → Export)
• •Continue using it directly in Notion with database views, filters, and formulas
• •Import the CSV into any other app

The limitation here is that the Notion database only contains saves that were synced while the integration was active. If you saved articles directly in Pocket without the Notion sync, those saves are only in the HTML export file.

Step-by-step: convert your Pocket export and import to Burn 451

If you want to use Burn 451 as your new read-later app and carry your Pocket history as a reference archive, here's the full flow:

After import, your Pocket history is searchable in Burn's vault. You can query it through the Burn MCP server with Claude Desktop: "show me everything I saved about machine learning from 2023" works as a natural language query against your full Pocket archive.

What the Pocket HTML file looks like (and why it's awkward to work with)

Here's a sample of what's inside ril_export.html:

<ul>
  <li>
    <a href="https://example.com/article"
       time_added="1714521600"
       time_read="1714608000"
       tags="ai,productivity">
      Article Title Here
    </a>
  </li>
</ul>

The Unix timestamp format ( time_added="1714521600") is why it's not directly parseable by most tools — spreadsheets don't know how to interpret that as a human date without a conversion step. The tags are comma-separated in a single attribute string rather than a proper array. There's no unique ID per item. These are all solvable problems, but they require an explicit conversion step before the data is usable.

The full guide to what to do after the Pocket shutdown covers data recovery options, export deadlines, and migration paths in more detail.

Choosing the right conversion method

The decision tree is simple:

• •You want a CSV/JSON/Markdown file: use the Python script — runs locally, any file size, full control.
• •You need custom fields or automated pipelines: use the Python script.
• •Your destination is Raindrop.io: skip conversion, import the HTML file directly.
• •You used the Pocket–Notion integration: check your Notion workspace first — you may already have a database there.

For the broader context on which read-later app to land on after Pocket, the pocket alternative app guide covers mobile-first options and the best read-later app 2026 guide covers the full landscape including self-hosted options.

Related reading

• •Pocket Alternative 2026 — 8 apps compared after the shutdown (pillar)
• •Pocket Replacement 2026 — what to switch to and how to migrate
• •Pocket Shutdown: What Now? Your data, your options, your next step
• •Pocket Alternative App 2026 — 6 mobile read-later apps compared
• •Best Read-Later App 2026: 10 tools tested
• •Burn 451 MCP server — query your saves from Claude

Frequently asked questions