Een Claude-gesprek opslaan als Markdown (Artifacts, citaten, Projects)

Claude-gesprekken zijn steeds vaker de plek waar serieus onderzoek en codewerk plaatsvindt. Lange threads met Artifacts, citaten en uren heen-en-weer bevatten vaak meer redenering dan welk document in je notities ook. Toch biedt Anthropic geen export. Er is geen “downloaden als Markdown”-knop, geen JSON-dump, geen archief-endpoint. Zodra een thread uit je zijbalk scrolt, is de enige weg terug een zoekopdracht op claude.ai die niet altijd terug brengt wat je je herinnert.

Claude-gesprekken opslaan als Markdown lost drie dingen tegelijk op: je krijgt een permanent lokaal archief, je kunt verwijzen naar eerdere redenering vanuit Obsidian of Notion, en je kunt een oude Claude-thread terugvoeren naar ChatGPT of Gemini als context wanneer je van model wisselt.

Deze gids dekt elke methode om een Claude-gesprek te converteren naar schone Markdown --- van een snelle chat tot een onderzoekthread van 200K tokens met Artifacts.

Waarom Claude-gesprekken opslaan als Markdown?

Markdown is het formaat dat werkt waar een gesprek ook naartoe moet:

• Voer het aan een andere LLM --- plak een oude Claude-thread in ChatGPT, Gemini of een lokaal model wanneer je een tweede mening of een andere redeneerstijl wilt
• Drop het in Obsidian of Notion --- één bestand per gesprek, volledig doorzoekbaar, te linken vanuit projectnotities
• Citeer een specifieke beurt --- “het moment waarop Claude de refactor voorstelde” vinden in een thread van 50 beurten is één zoekopdracht ver
• Archiveer Artifacts als echte bestanden --- de code, het document, het React-component dat Claude bouwde wordt een codeblok dat je naar een repo kunt kopiëren
• Behoud citaten --- websearch-resultaten waarop Claude zijn antwoord baseerde, worden voetnoten die je later kunt verifiëren

De use case die in 2026 het meeste Claude-naar-Markdown-verkeer aandrijft is de eerste: mensen gebruiken Claude voor diep werk, en willen vervolgens de output en de redenering bewaren, niet alleen het eindantwoord.

Methode 1: Save (snelste, één klik)

Save is een Chrome-extensie die elk Claude-gesprek met één klik omzet in een Markdown-bestand. Hij loopt door de DOM van het gesprek, haalt elke gebruikers- en assistent-beurt in volgorde eruit, trekt Artifacts eruit als codeblokken met de juiste taalidentificator, en behoudt citaten als voetnoten.

Hoe het werkt:

1. Open het Claude-gesprek in Chrome (werkt op claude.ai/chat/... en gedeelde gesprekslinks)
2. Klik op het Save-extensie-icoon in je werkbalk
3. Een .md-bestand wordt direct gedownload (of belandt in je Save Vault als die verbonden is)

Wat je krijgt:

• Gesprekstitel en datum als frontmatter
• Elke gebruikers- en assistent-beurt, in volgorde, met rollabels (## You / ## Claude)
• Claude Artifacts (code, documenten, HTML, React-componenten) geëxtraheerd als codeblokken met de juiste taalidentificator
• Codeblokken binnen antwoorden met taalhints behouden
• Citaten uit Claude’s websearch-resultaten als Markdown-voetnoten
• Tool-use-beurten vastgelegd wanneer Claude een tool aanroept (zowel de aanroep als het resultaat verschijnen)
• Project-context behouden wanneer het gesprek binnen een Claude Project zit en de system prompt of kennisbestanden zichtbaar zijn

Wat verwijderd wordt:

• Claude.ai navigatie-chrome, zijbalk, modelkiezer
• Lege geregenereerde branches die je niet hebt gekozen
• Inline UI-affordances (“Edit”, “Copy”, “Retry”-knoppen)
• Laadskeletten en partiële streams

Het meest geschikt voor: Onderzoekers, engineers, AI-gebruikers, iedereen die lange threads in Claude voert en het werk wil bewaren. Als je een schoon transcript nodig hebt om in een ander model te plakken, in Obsidian te archiveren of aan een teamgenoot te overhandigen, is dit het schoonste pad.

Voorbeeld output

Een kort Claude-gesprek met een Artifact opslaan levert dit op:

---
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()
})

Dat bestand is één plakactie verwijderd van bruikbare ChatGPT-context, één toetsaanslag verwijderd van een permanente Obsidian-notitie, en de Artifact erin is één kopie verwijderd van het gecommit worden in een repo.

## Methode 2: handmatig kopiëren-plakken

Claude.ai laat je tekst selecteren in het gesprekspaneel en kopiëren zoals elke webpagina.

**Stappen:**

1. Scroll naar de bovenkant van het gesprek
2. Klik en sleep om elke beurt te selecteren
3. Kopiëer, plak in een Markdown-editor
4. Voeg handmatig rollabels toe, herstel codeblok-fences, voeg Artifact-inhoud die niet doorkwam opnieuw toe, herbouw citaatlinks

**Problemen met deze aanpak:**

- Het volledige gesprek selecteren in een lange thread is fragiel --- Claude virtualiseert de DOM, dus scrollen laat eerdere beurten uit het document vallen
- Artifacts kopiëren niet als tekst; je krijgt een placeholder of niets
- Codeblokken verliezen hun taalhints
- Websearch-citaten komen door als `[1]` `[2]` zonder bestemmings-URL
- Rolgrenzen storten in --- gebruikers- en Claude-beurten lopen in elkaar tot één muur van tekst
- Vertakte gesprekken (waar je een antwoord regenereerde) brengen alle branches tegelijk

Werkbaar voor een uitwisseling van 2 beurten. Stort in op alles langer dan een scherm.

## Methode 3: browserconsole + script

Voor ontwikkelaars leven de gespreksdata in de DOM. Je kunt een klein script schrijven in de Chrome DevTools-console om er doorheen te lopen.

```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)

Het meest geschikt voor: Engineers die eenmalige controle willen over de output, of die bulk-extractie over veel threads moeten scripten.

Problemen met deze aanpak:

• De selectors maken geen deel uit van enige openbare API; Anthropic verscheept regelmatig UI-wijzigingen en het script breekt zonder waarschuwing
• Artifacts worden gerenderd in iframes of out-of-tree React-portalen; innerText mist ze
• Citaten leven in tooltips die niet in de initiële DOM zitten
• Tool-use-beurten zijn anders genest dan tekst-beurten
• Je moet ingelogd zijn en op het gesprekstabblad; werkt niet als batchtaak

Een redelijke vluchtroute wanneer je de omgeving beheerst. Geen methode om op te vertrouwen.

Methode 4: Anthropic’s Workbench API (gesprekken reconstrueren)

De Anthropic API stelt gespreksprimitieven beschikbaar via het Messages-endpoint, maar er is geen endpoint dat je vroegere claude.ai-gesprekken teruggeeft. De API ziet alleen gesprekken die je er doorheen stuurde. Om een claude.ai-thread programmatisch te reconstrueren, zou je hem zelf opnieuw moeten afspelen.

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": "..." }]
  }'

Het meest geschikt voor: Teams die hun eigen Claude-wrappers bouwen die gesprekken in hun eigen database opslaan. Als jij de calls beheerst, beheers je de export.

Problemen voor het bestaand-gesprek-gebruik:

• Vroegere claude.ai-gesprekken zijn niet bereikbaar via de API
• Vereist API-credits en je eigen opslaglaag
• Helpt niet bij het archiveren van een thread die je al had in de web-UI
• Artifacts zijn ook een API-feature, maar de renderpipeline is van de web-app, niet van de API

Dit is de juiste methode als je een product bouwt. Het is de verkeerde methode als je gisteren’s onderzoekthread probeert te archiveren.

Welke methode moet je gebruiken?

Scenario	Beste methode
Een Claude-onderzoekthread archiveren die je al had	Save --- één klik, gestructureerde output
Een oud Claude-gesprek plakken in ChatGPT of Gemini	Save --- elke beurt, Artifacts intact
Een Artifact (code, doc, React) bewaren dat Claude voor je bouwde	Save --- geëxtraheerd als codeblok
Een thread in Obsidian droppen naast projectnotities	Save --- schone frontmatter en kopjes
Je eigen gespreks-logger vanaf nul bouwen	Anthropic API --- als je de calls beheerst
Snelle ruwe kopie van een uitwisseling van 2 beurten	Handmatig kopiëren-plakken --- gratis, snel, rommelig
Eenmalige extractie met aangepaste transformaties	Console-script --- als je vertrouwd bent met selectors

Voor de meeste mensen --- vooral wie Claude gebruikt voor onderzoek, engineering of schrijven --- is Save het antwoord. Het produceert de schoonste Markdown zonder enige setup, en het verwerkt threads van 200K tokens op dezelfde snelheid als een chat van één beurt.

Randgevallen die Save afhandelt

• Claude Projects. Elk gesprek binnen een Project wordt geëxtraheerd als zelfstandig bestand. Wanneer de system prompt of kennisbestanden van het Project zichtbaar zijn in de gesprekskop, legt Save ze vast in de frontmatter zodat de context niet verloren gaat.
• Multi-Artifact-gesprekken. Threads waarin Claude drie Artifacts bouwde (bijv. een HTML-pagina, een React-component en een SQL-schema) komen eruit met elk Artifact als eigen codeblok, in de volgorde waarin ze verschenen, met de juiste taalidentificator.
• Zeer lange gesprekken. Claude’s 200K-contextvenster kan threads produceren met honderden beurten en tienduizenden woorden. Save streamt de DOM terwijl het scrollt, zodat de volledige thread doorkomt zonder eerdere beurten te verliezen.
• Vertakte en geregenereerde antwoorden. Wanneer je een Claude-antwoord regenereerde, wordt alleen de branch die je hield (de momenteel getoonde) geëxporteerd. Weggegooide branches worden overgeslagen.
• Tool-use-beurten. Wanneer Claude een tool aanroept --- websearch, code-uitvoering, computer use --- worden zowel de aanroep als het resultaat vastgelegd als codeblokken met tool_use- en tool_result-markeringen, zodat de redeneerketen intact blijft.
• Gedeelde gesprekslinks. claude.ai/share/...-URLs werken hetzelfde als je eigen gesprekken. Handig voor het archiveren van een thread die iemand met je deelde.
• Computer Use-sessies. Beperkt tot wat zichtbaar is in de DOM --- de screenshots en de redenering van het model komen door, de onderliggende VM-toestand niet.
• Claude Code-gesprekken. Claude Code draait in je terminal, niet in claude.ai. Voor terminalsessies, zie de Claude Code + Obsidian workflow-gids om ze apart vast te leggen.

Combineer het met je workflow

De Markdown-output werkt waar je hem ook nodig hebt:

• ChatGPT / Gemini / lokale modellen --- plak het bestand erin, stel vervolgvragen tegen een ander model
• Obsidian --- drop het in je vault, link het vanuit projectnotities, zoek door elke Claude-thread die je ooit hebt opgeslagen
• Notion --- plak direct, kopjes en Artifact-codeblokken renderen correct
• Apple Notes --- schone import via de Markdown-deel-extensie
• Een git-repo --- commit Artifacts direct vanuit de codeblokken in het juiste bestand
• Save Vault --- als je er een hebt verbonden, belandt elke Claude-save daar automatisch met backlinks en tags

FAQ

Werkt Save op gedeelde gesprekslinks? Ja. Alles op claude.ai/share/... exporteert op dezelfde manier als je eigen gesprekken. Handig voor het archiveren van threads die collega’s je sturen.

Hoe zit het met Claude Projects? Elk gesprek binnen een Project wordt afzonderlijk opgeslagen. Wanneer de system prompt of kennisbestanden van het Project zichtbaar zijn op de pagina (kop of zijbalk), legt Save ze vast in de frontmatter zodat je de context waarvan het gesprek afhing niet verliest.

Legt het Artifacts vast? Ja --- dit is de kerndifferentiator. Artifacts (code, documenten, HTML, React-componenten, Mermaid-diagrammen) komen door als codeblokken met de juiste taalidentificator, in de volgorde waarin Claude ze bouwde. Je kunt ze direct naar een repo of document kopiëren.

Hoe zit het met citaten uit Claude’s websearch? Citaten worden behouden als Markdown-voetnoten. De voetnootstekst is de bron-URL, zodat je Claude’s onderbouwing later kunt verifiëren zonder terug te gaan naar de originele thread.

Werkt het in Claude Code (de CLI)? Claude Code draait in je terminal, niet in de browser. De extensie richt zich op claude.ai. Voor CLI-sessies leeft het gesprekstranscript op schijf in ~/.claude/ en kan apart worden vastgelegd --- de Claude Code + Obsidian workflow-gids behandelt dat.

Verwerkt het zeer lange threads? Ja. Claude’s 200K-context kan gesprekken produceren met honderden beurten. Save scrollt het gesprekspaneel en leest elke beurt terwijl die terug in de DOM virtualiseert, zodat zelfs de langste threads volledig doorkomen.

Worden vertakte antwoorden meegenomen? Alleen de branch die momenteel in de UI wordt getoond (degene die je hield). Geregenereerde branches die je niet koos worden overgeslagen zodat het bestand overeenkomt met het gesprek zoals Claude het je toont.

Hoeveel kost het? Save heeft een gratis laag zodat je het op een paar gesprekken kunt proberen. Daarna dekt een klein abonnement het voortdurende gebruik.

Gerelateerde Save-gidsen

• ChatGPT-gesprekken opslaan als Markdown --- elke beurt, met codeblokken intact
• YouTube-video’s opslaan als Markdown --- AI-transcript, samenvatting, tijdstempels
• GitHub-repo’s en issues opslaan als Markdown --- README, issues, PR-discussies, alles in één bestand
• Claude Code + Obsidian kennisbank-workflow --- terminalsessies vastleggen en een doorzoekbaar archief opbouwen

Footnotes

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