How to Save a Claude Conversation as Markdown (Artifacts, Citations, Projects)

Claude conversations are increasingly the place where serious research and code work happen. Long threads with Artifacts, citations, and multi-hour back-and-forth often hold more reasoning than any document in your notes. And yet Anthropic provides no export. There’s no “download as Markdown” button, no JSON dump, no archive endpoint. Once a thread scrolls past your sidebar, the only way back in is a search across claude.ai that doesn’t always surface what you remember.

Saving Claude conversations as Markdown solves three things at once: you get a permanent local archive, you can reference past reasoning inside Obsidian or Notion, and you can feed an old Claude thread back into ChatGPT or Gemini as context when you switch models.

This guide covers every method to convert a Claude conversation to clean Markdown --- from a quick chat to a 200K-token research thread with Artifacts.

Why Save Claude Conversations as Markdown?

Markdown is the format that works wherever a conversation needs to go:

• Feed it to another LLM --- paste an old Claude thread into ChatGPT, Gemini, or a local model when you want a second opinion or a different reasoning style
• Drop it into Obsidian or Notion --- one file per conversation, fully searchable, linkable from project notes
• Quote a specific turn --- finding “the moment Claude proposed the refactor” in a 50-turn thread is one search away
• Archive Artifacts as real files --- the code, the doc, the React component Claude built becomes a fenced code block you can copy into a repo
• Preserve citations --- web-search results that Claude grounded its answer in become footnotes you can audit later

The use case driving most Claude-to-Markdown traffic in 2026 is the first one: people use Claude for deep work, then want to keep the output and the reasoning, not just the final answer.

Method 1: Save (Fastest, One Click)

Save is a Chrome extension that turns any Claude conversation into a Markdown file with one click. It walks the conversation DOM, extracts every user and assistant turn in order, pulls Artifacts out as fenced code blocks with the right language identifier, and preserves citations as footnotes.

How it works:

1. Open the Claude conversation in Chrome (works on claude.ai/chat/... and shared conversation links)
2. Click the Save extension icon in your toolbar
3. A .md file downloads instantly (or lands in your Save Vault if connected)

What you get:

• Conversation title and date as frontmatter
• Every user and assistant turn, in order, with role labels (## You / ## Claude)
• Claude Artifacts (code, documents, HTML, React components) extracted as fenced code blocks with the right language identifier
• Code blocks inside replies with language hints preserved
• Citations from Claude’s web-search results as Markdown footnotes
• Tool-use turns captured when Claude calls a tool (the call and the result both appear)
• Project context preserved when the conversation is inside a Claude Project and the system prompt or knowledge files are visible

What gets removed:

• Claude.ai nav chrome, sidebar, model picker
• Empty regenerated branches that you didn’t pick
• Inline UI affordances (“Edit”, “Copy”, “Retry” buttons)
• Loading skeletons and partial streams

Best for: Researchers, engineers, AI users, anyone who runs long threads in Claude and wants to keep the work. If you need a clean transcript that you’ll paste into another model, archive in Obsidian, or hand to a teammate, this is the cleanest path.

Example Output

Saving a short Claude conversation with an Artifact produces:

---
title: "Refactor my Express middleware into Hono"
url: https://claude.ai/chat/a1b2c3d4-...
model: Claude Opus 4.7
date: 2026-05-22
turns: 6
---

## You

Here's my Express middleware. Can you port it to Hono? I want to keep
the same auth behavior but drop the body-parser dependency.

```js
app.use((req, res, next) => {
  if (!req.headers.authorization) return res.sendStatus(401)
  // ...
})

Claude

Hono ships JSON parsing in core, so the body-parser dependency goes away on its own. The middleware shape is almost identical --- c.req instead of req, and you return instead of calling next().

Here’s the port ¹:

import { Hono } from 'hono'

const app = new Hono()

app.use('*', async (c, next) => {
  const auth = c.req.header('Authorization')
  if (!auth) return c.text('Unauthorized', 401)
  await next()
})

That file is one paste away from being usable ChatGPT context, one keystroke away from being a permanent Obsidian note, and the Artifact inside it is one copy away from being committed to a repo.

## Method 2: Manual Copy-Paste

Claude.ai lets you select text in the conversation pane and copy it like any web page.

**Steps:**

1. Scroll to the top of the conversation
2. Click and drag to select every turn
3. Copy, paste into a Markdown editor
4. Manually add role labels, fix code block fences, re-add Artifact contents that didn't come through, reconstruct citation links

**Problems with this approach:**

- Selecting the full conversation in a long thread is fragile --- Claude virtualizes the DOM, so scrolling drops earlier turns from the document
- Artifacts don't copy as text; you get a placeholder or nothing
- Code blocks lose their language hints
- Web-search citations come through as `[1]` `[2]` with no destination URL
- Role boundaries collapse --- user and Claude turns blur into one wall of text
- Branched conversations (where you regenerated a response) bring all branches at once

Workable for a 2-turn exchange. Falls apart on anything longer than a screen.

## Method 3: Browser Console + Script

For developers, the conversation data lives in the DOM. You can write a small script in the Chrome DevTools console to walk it.

```js
const turns = document.querySelectorAll('[data-testid="conversation-turn"]')
const md = Array.from(turns).map(t => {
  const role = t.querySelector('[data-role]')?.dataset.role
  const body = t.querySelector('.prose')?.innerText
  return `## ${role === 'user' ? 'You' : 'Claude'}\n\n${body}`
}).join('\n\n---\n\n')
console.log(md)

Best for: Engineers who want one-off control over the output, or who need to script bulk extraction across many threads.

Problems with this approach:

• The selectors are not part of any public API; Anthropic ships UI changes regularly and the script breaks without warning
• Artifacts are rendered inside iframes or out-of-tree React portals; innerText misses them
• Citations live in tooltips that aren’t in the initial DOM
• Tool-use turns are nested differently than text turns
• You need to be logged in and on the conversation tab; doesn’t work as a batch job

A reasonable escape hatch when you control the environment. Not a method to rely on.

Method 4: Anthropic’s Workbench API (Reconstructing Conversations)

The Anthropic API exposes conversation primitives through the Messages endpoint, but there is no endpoint that returns your past claude.ai conversations. The API only sees conversations you sent through it. To reconstruct a claude.ai thread programmatically, you’d need to replay it yourself.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-4-5",
    "messages": [{ "role": "user", "content": "..." }]
  }'

Best for: Teams building their own Claude wrappers that store conversations in their own database. If you control the calls, you control the export.

Problems for the existing-conversation use case:

• Past claude.ai conversations are not reachable through the API
• Requires API credits and your own storage layer
• Doesn’t help you archive a thread you already had in the web UI
• Artifacts are an API feature too, but the rendering pipeline is the web app’s, not the API’s

This is the right method if you’re building a product. It’s the wrong method if you’re trying to archive yesterday’s research thread.

Which Method Should You Use?

Scenario	Best Method
Archive a Claude research thread you already had	Save --- one click, structured output
Paste an old Claude conversation into ChatGPT or Gemini	Save --- every turn, Artifacts intact
Keep an Artifact (code, doc, React) Claude built for you	Save --- extracted as a fenced code block
Drop a thread into Obsidian alongside project notes	Save --- clean frontmatter and headings
Build your own conversation logger from scratch	Anthropic API --- if you control the calls
Quick rough copy of a 2-turn exchange	Manual copy-paste --- free, fast, messy
One-off extraction with custom transformations	Console script --- if you’re comfortable with selectors

For most people --- especially anyone using Claude for research, engineering, or writing --- Save is the answer. It produces the cleanest Markdown with zero setup, and it handles 200K-token threads at the same speed as a one-turn chat.

Edge Cases Save Handles

• Claude Projects. Each conversation inside a Project extracts as a standalone file. When the Project’s system prompt or knowledge files are visible in the conversation header, Save captures them in the frontmatter so the context isn’t lost.
• Multi-Artifact conversations. Threads where Claude built three Artifacts (e.g. an HTML page, a React component, and a SQL schema) come out with each Artifact as its own fenced code block, in the order they appeared, with the right language identifier.
• Very long conversations. Claude’s 200K context window can produce threads with hundreds of turns and tens of thousands of words. Save streams the DOM as it scrolls, so the full thread comes through without dropping earlier turns.
• Branched and regenerated responses. When you regenerated a Claude reply, only the branch you kept (the one currently shown) gets exported. Discarded branches are skipped.
• Tool-use turns. When Claude calls a tool --- web search, code execution, computer use --- both the call and the result are captured as code blocks with tool_use and tool_result markers so the chain of reasoning stays intact.
• Shared conversation links. claude.ai/share/... URLs work the same as your own conversations. Useful for archiving a thread someone shared with you.
• Computer Use sessions. Limited to what’s visible in the DOM --- the screenshots and the model’s reasoning come through, the underlying VM state doesn’t.
• Claude Code conversations. Claude Code runs in your terminal, not in claude.ai. For terminal sessions, see the Claude Code + Obsidian workflow guide for capturing those separately.

Pair It With Your Workflow

The Markdown output works wherever you need it:

• ChatGPT / Gemini / local models --- paste the file in, ask follow-up questions against a different model
• Obsidian --- drop it in your vault, link it from project notes, search across every Claude thread you’ve ever saved
• Notion --- paste directly, headings and Artifact code blocks render correctly
• Apple Notes --- clean import via the Markdown share extension
• A git repo --- commit Artifacts straight from the fenced code blocks into the right file
• Save Vault --- if you’ve connected one, every Claude save lands there automatically with backlinks and tags

FAQ

Does Save work on shared conversation links? Yes. Anything at claude.ai/share/... exports the same way as your own conversations. Useful for archiving threads colleagues send you.

What about Claude Projects? Each conversation inside a Project is saved individually. When the Project system prompt or knowledge files are visible in the page (header or sidebar), Save captures them in the frontmatter so you don’t lose the context the conversation depended on.

Does it capture Artifacts? Yes --- this is the core differentiator. Artifacts (code, documents, HTML, React components, Mermaid diagrams) come through as fenced code blocks with the right language identifier, in the order Claude built them. You can copy them directly into a repo or a document.

What about citations from Claude’s web search? Citations are preserved as Markdown footnotes. The footnote text is the source URL, so you can audit Claude’s grounding later without going back to the original thread.

Will it work in Claude Code (the CLI)? Claude Code runs in your terminal, not in the browser. The extension targets claude.ai. For CLI sessions, the conversation transcript lives on disk in ~/.claude/ and can be captured separately --- the Claude Code + Obsidian workflow guide covers that.

Does it handle very long threads? Yes. Claude’s 200K context can produce conversations with hundreds of turns. Save scrolls the conversation pane and reads every turn as it virtualizes back into the DOM, so even the longest threads come through complete.

Are branched responses included? Only the branch currently shown in the UI (the one you kept). Regenerated branches you didn’t pick are skipped so the file matches the conversation as Claude shows it to you.

How much does it cost? Save has a free tier so you can try it on a few conversations. After that, a small subscription covers ongoing use.

Related Save Guides

• Save ChatGPT Conversations as Markdown --- every turn, with code blocks intact
• Save YouTube Videos as Markdown --- AI transcript, summary, timestamps
• Save GitHub Repos and Issues as Markdown --- README, issues, PR discussions, all as one file
• Claude Code + Obsidian Knowledge-Base Workflow --- capturing terminal sessions and building a queryable archive

Footnotes

1. https://hono.dev/docs/guides/middleware ↩