Bluesky to Markdown 2026: Save Posts as Markdown

Bluesky is built on the AT Protocol (“atproto”), and that choice makes it one of the easiest social platforms in 2026 to export. Every public post, thread, and author feed is served by a public API that returns clean JSON — no account, no token, and no rate-limit handshake for basic reads. That means “Bluesky to Markdown” is not a niche workaround; it is a normal, supported workflow.

This guide shows why saving Bluesky posts as Markdown is worth doing, how the public atproto endpoints work, and the fastest routes to a portable local archive — from a single curl to a batch script you can run on your whole timeline.

Why Save Bluesky Posts as Markdown

Bluesky is more open than most networks, but open does not mean permanent. Posts can be deleted, handles can change, and an account or instance issue can take your reading list with it. If a post matters — a research note, a useful thread, a reference you will cite later — the only copy you truly control is the one on your own disk.

Markdown is the right format for that job for three concrete reasons:

• It is plain text. You can search it, grep it, and read it in any editor or notes app now and in ten years.
• It version-checks. Drop it in git and you can diff a post against an edited version, which matters when you are tracking changes or corrections.
• It feeds AI workflows. LLMs, agents, and RAG pipelines ingest Markdown far more cleanly than captured images or web scrapers.

A screenshot preserves the pixels, not the content. Markdown preserves the words, the structure, the links, and the metadata — which is why the archiving community has standardized on it.

How the Bluesky Public API Works

Bluesky runs on atproto, and the read paths are deliberately public. Two endpoints do almost all the work for archiving:

• com.atproto.identity.resolveHandle — turns a handle like @bsky.app into a persistent DID (did:plc:...).
• app.bsky.feed.getAuthorFeed (and getPosts) — returns recent posts for that DID as JSON, including the post text and timestamps.

The base URL is https://public.api.bsky.app. The full endpoint reference is published by Bluesky at docs.bsky.app, and the feed endpoint documents the exact response shape. There is no login step for public content: you resolve, you fetch, you are done. The response is structured JSON, so converting it to Markdown is a few lines of code in any language.

Method 1 — Save a Single Post with curl

The fastest way to grab one Bluesky post as Markdown is to call the public API directly. First, resolve the author’s handle to a DID:

curl "https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle=bsky.app"

The response returns the persistent identifier:

{ "did": "did:plc:z72i7hdynmk6r22z27h6tvur" }

Now fetch the author’s feed, keeping only the fields you want. A short Python one-liner turns the JSON into clean Markdown bullets:

import json, urllib.request
did = "did:plc:z72i7hdynmk6r22z27h6tvur"
url = ("https://public.api.bsky.app/xrpc/app.bsky.feed.getAuthorFeed"
       "?actor=" + did + "&limit=5")
data = json.load(urllib.request.urlopen(url))
for item in data["feed"]:
    rec = item["post"]["record"]
    print("## " + rec.get("createdAt", "")[:10])
    print(rec.get("text", "") + "\n")

Run it and you get a readable Markdown block per post — the date as a heading, the text as a paragraph. That is the whole workflow for a single manual save.

Method 2 — Batch-Archive a Whole Timeline

For an entire account’s recent posts, add pagination. getAuthorFeed returns a cursor you pass back to fetch the next page, so a small loop captures everything without missing anything:

import json, urllib.request, urllib.parse
did = "did:plc:z72i7hdynmk6r22z27h6tvur"
cursor = None
for page in range(3):
    params = {"actor": did, "limit": 50}
    if cursor:
        params["cursor"] = cursor
    url = ("https://public.api.bsky.app/xrpc/app.bsky.feed.getAuthorFeed?"
           + urllib.parse.urlencode(params))
    data = json.load(urllib.request.urlopen(url))
    for item in data.get("feed", []):
        rec = item["post"]["record"]
        print("## " + rec.get("createdAt", "")[:10] + "\n"
              + rec.get("text", "") + "\n")
    cursor = data.get("cursor")
    if not cursor:
        break

Each run appends the posts to a Markdown file, and the cursor guarantees you see every page. Run it weekly inside a cron job and you get a rolling, searchable archive of any Bluesky account you follow.

Method 3 — ThreadGrab for Cross-Platform Markdown

The API route is powerful but hands-on. If you want the same result for X threads, X long-form Articles, and Bluesky posts without writing and maintaining scripts, ThreadGrab wraps the “grab the content, keep the Markdown” pattern into one tool. It converts social posts to clean Markdown, downloads linked media to your own storage, and gives you a portable library that does not depend on any single platform’s API or pricing.

That matters when your archive spans platforms. A single-script API approach works beautifully for one Bluesky account; a mixed X-and-Bluesky library benefits from a tool that normalizes the output format everywhere.

Which Method Should You Use?

There is no single right answer. Start with the curl one-liner to prove the concept, then level up to a paged script or ThreadGrab as your archive grows.

Building a Portable Bluesky Archive

Whichever method you pick, keep the output structured so it stays useful. A simple convention beats a clever one:

bluesky-archive/
  profile.json
  2026-08-05-bsky-app.md
  2026-08-04-group-chats-100.md
  media/
    image-01.jpg

Name each file by the post’s date and slug, store the DID and capture time in a small profile.json alongside, and keep image links relative so the folder mirrors cleanly anywhere. Because everything is plain text plus files, the archive is portable across git repos, cloud drives, and local disks — no Bluesky server required to read it.

The Bottom Line

Bluesky’s atproto design is a genuine advantage for archiving. Public posts are one public API call away from clean Markdown — no auth, no paywall, no proprietary export tool. Whether you grab a single post with curl, page an entire timeline with a short script, or use ThreadGrab to keep X and Bluesky in one normalized library, the outcome is the same: content you actually control.

Posts disappear, handles change, algorithms move on. The Markdown you saved today is the copy you can still read next year — and the copy you can feed to any tool, LLM, or notes app that comes next.

FAQ