Slik lagrer du en Claude-samtale som Markdown (Artifacts, sitater, Projects)

Claude-samtaler er i økende grad stedet der seriøs forskning og kodearbeid skjer. Lange tråder med Artifacts, sitater og utveksling over flere timer inneholder ofte mer resonnement enn noe dokument i notatene dine. Likevel tilbyr Anthropic ingen eksport. Det finnes ingen “last ned som Markdown”-knapp, ingen JSON-dump, ingen arkiv-endpoint. Når en tråd ruller forbi sidefeltet ditt, er den eneste veien tilbake et søk på tvers av claude.ai som ikke alltid får frem det du husker.

Å lagre Claude-samtaler som Markdown løser tre ting på én gang: du får et permanent lokalt arkiv, du kan referere til tidligere resonnement inne i Obsidian eller Notion, og du kan mate en gammel Claude-tråd tilbake til ChatGPT eller Gemini som kontekst når du bytter modell.

Denne guiden dekker alle metoder for å konvertere en Claude-samtale til ren Markdown --- fra en rask chat til en forskningstråd på 200K tokens med Artifacts.

Hvorfor lagre Claude-samtaler som Markdown?

Markdown er formatet som fungerer overalt der en samtale må gå:

• Mate den til en annen LLM --- lim inn en gammel Claude-tråd i ChatGPT, Gemini eller en lokal modell når du ønsker en andre mening eller en annen resonnementsstil
• Slipp den i Obsidian eller Notion --- én fil per samtale, fullt søkbar, lenkbar fra prosjektnotater
• Sitere en spesifikk tur --- å finne “øyeblikket Claude foreslo refaktoreringen” i en tråd med 50 turer er ett søk unna
• Arkivere Artifacts som ekte filer --- koden, dokumentet, React-komponenten Claude bygde, blir en kodeblokk du kan kopiere inn i et repo
• Bevare sitater --- websøkeresultater Claude baserte svaret sitt på blir fotnoter du kan revidere senere

Bruksområdet som driver mest Claude-til-Markdown-trafikk i 2026 er det første: folk bruker Claude til dyptgående arbeid, og vil deretter beholde resultatet og resonnementet, ikke bare det endelige svaret.

Metode 1: Save (raskest, ett klikk)

Save er en Chrome-utvidelse som gjør hvilken som helst Claude-samtale om til en Markdown-fil med ett klikk. Den går gjennom samtalens DOM, trekker ut hver bruker- og assistenttur i rekkefølge, drar Artifacts ut som kodeblokker med riktig språkidentifikator, og bevarer sitater som fotnoter.

Slik fungerer det:

1. Åpne Claude-samtalen i Chrome (fungerer på claude.ai/chat/... og delte samtalelenker)
2. Klikk på Save-utvidelsesikonet i verktøylinjen din
3. En .md-fil lastes ned umiddelbart (eller havner i Save Vault hvis tilkoblet)

Hva du får:

• Samtaletittel og dato som frontmatter
• Hver bruker- og assistenttur, i rekkefølge, med rolleetiketter (## You / ## Claude)
• Claude Artifacts (kode, dokumenter, HTML, React-komponenter) trukket ut som kodeblokker med riktig språkidentifikator
• Kodeblokker inne i svar med språkhints bevart
• Sitater fra Claudes websøkeresultater som Markdown-fotnoter
• Verktøybruk-turer fanges når Claude kaller et verktøy (både kallet og resultatet vises)
• Project-kontekst bevart når samtalen er inne i et Claude Project og system prompten eller kunnskapsfilene er synlige

Hva som fjernes:

• Claude.ai navigasjonschrome, sidefelt, modellvelger
• Tomme regenererte grener du ikke valgte
• Inline UI-affordances (knappene “Edit”, “Copy”, “Retry”)
• Lasteskjeletter og delvise strømmer

Best for: Forskere, ingeniører, AI-brukere, alle som kjører lange tråder i Claude og vil beholde arbeidet. Hvis du trenger en ren transkripsjon du skal lime inn i en annen modell, arkivere i Obsidian eller overlevere til en kollega, er dette den reneste veien.

Eksempelutdata

Å lagre en kort Claude-samtale med en Artifact produserer:

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

Den filen er én innliming unna å være brukbar ChatGPT-kontekst, ett tastetrykk unna å være et permanent Obsidian-notat, og Artifact'en i den er én kopiering unna å bli committed til et repo.

## Metode 2: Manuell kopier-lim inn

Claude.ai lar deg merke tekst i samtalepanelet og kopiere den som hvilken som helst nettside.

**Trinn:**

1. Rull til toppen av samtalen
2. Klikk og dra for å merke hver tur
3. Kopier, lim inn i en Markdown-editor
4. Legg manuelt til rolleetiketter, fiks kodeblokk-gjerder, legg til igjen Artifact-innhold som ikke kom gjennom, rekonstruer sitatlenker

**Problemer med denne tilnærmingen:**

- Å merke hele samtalen i en lang tråd er skjørt --- Claude virtualiserer DOM-en, så rulling slipper tidligere turer fra dokumentet
- Artifacts kopieres ikke som tekst; du får en plassholder eller ingenting
- Kodeblokker mister sine språkhints
- Websøkesitater kommer gjennom som `[1]` `[2]` uten destinasjons-URL
- Rollegrenser kollapser --- bruker- og Claude-turer flyter sammen til én tekstvegg
- Forgrenede samtaler (der du regenererte et svar) bringer alle grener på én gang

Funksjonelt for en 2-tur utveksling. Faller fra hverandre på alt lengre enn en skjerm.

## Metode 3: Browser Console + skript

For utviklere lever samtaledata i DOM-en. Du kan skrive et lite skript i Chrome DevTools-konsollen for å gå gjennom det.

```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: Ingeniører som ønsker engangskontroll over utdataen, eller som trenger å skripte masseuttrekk på tvers av mange tråder.

Problemer med denne tilnærmingen:

• Selektorene er ikke en del av noe offentlig API; Anthropic ruller ut UI-endringer regelmessig og skriptet brytes uten advarsel
• Artifacts rendres inne i iframes eller React-portaler utenfor treet; innerText bommer på dem
• Sitater lever i tooltips som ikke er i den opprinnelige DOM-en
• Verktøybruk-turer er nestet annerledes enn tekstturer
• Du må være innlogget og på samtalefanen; fungerer ikke som batch-jobb

En rimelig nødutgang når du kontrollerer miljøet. Ikke en metode å stole på.

Metode 4: Anthropics Workbench API (rekonstruere samtaler)

Anthropic-API-et eksponerer samtaleprimitiver via Messages-endpointet, men det er ingen endpoint som returnerer dine tidligere claude.ai-samtaler. API-et ser bare samtaler du sendte gjennom det. For å rekonstruere en claude.ai-tråd programmatisk måtte du spille den av selv.

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: Team som bygger sine egne Claude-wrappere som lagrer samtaler i sin egen database. Hvis du kontrollerer kallene, kontrollerer du eksporten.

Problemer for bruksområdet med eksisterende samtaler:

• Tidligere claude.ai-samtaler er ikke tilgjengelige gjennom API-et
• Krever API-kreditter og ditt eget lagringslag
• Hjelper deg ikke med å arkivere en tråd du allerede hadde i web-UI
• Artifacts er også en API-funksjon, men render-pipelinen tilhører web-appen, ikke API-et

Dette er riktig metode hvis du bygger et produkt. Det er feil metode hvis du prøver å arkivere gårsdagens forskningstråd.

Hvilken metode bør du bruke?

Scenario	Beste metode
Arkivere en Claude-forskningstråd du allerede hadde	Save --- ett klikk, strukturert utdata
Lime inn en gammel Claude-samtale i ChatGPT eller Gemini	Save --- hver tur, Artifacts intakt
Beholde en Artifact (kode, doc, React) Claude bygde for deg	Save --- trukket ut som en kodeblokk
Slippe en tråd i Obsidian sammen med prosjektnotater	Save --- ren frontmatter og overskrifter
Bygge din egen samtale-logger fra bunnen av	Anthropic API --- hvis du kontrollerer kallene
Rask grov kopi av en 2-tur utveksling	Manuell kopier-lim inn --- gratis, raskt, rotete
Engangs-uttrekk med tilpassede transformasjoner	Konsoll-skript --- hvis du er komfortabel med selektorer

For de fleste --- spesielt alle som bruker Claude til forskning, ingeniørarbeid eller skriving --- er Save svaret. Den produserer den reneste Markdown med null oppsett, og den håndterer tråder på 200K tokens i samme hastighet som en én-tur chat.

Edge case-er Save håndterer

• Claude Projects. Hver samtale inne i et Project trekkes ut som en frittstående fil. Når Projectets system prompt eller kunnskapsfiler er synlige i samtaleoverskriften, fanger Save dem i frontmatteren slik at konteksten ikke går tapt.
• Multi-Artifact-samtaler. Tråder der Claude bygde tre Artifacts (f.eks. en HTML-side, en React-komponent og et SQL-skjema) kommer ut med hver Artifact som sin egen kodeblokk, i rekkefølgen de dukket opp, med riktig språkidentifikator.
• Veldig lange samtaler. Claudes 200K kontekstvindu kan produsere tråder med hundrevis av turer og titusenvis av ord. Save strømmer DOM-en mens den ruller, så hele tråden kommer gjennom uten å slippe tidligere turer.
• Forgrenede og regenererte svar. Når du regenererte et Claude-svar, eksporteres bare grenen du beholdt (den som vises nå). Forkastede grener hoppes over.
• Verktøybruk-turer. Når Claude kaller et verktøy --- websøk, kodeeksekvering, computer use --- fanges både kallet og resultatet som kodeblokker med tool_use- og tool_result-markører slik at resonnementskjeden forblir intakt.
• Delte samtalelenker. claude.ai/share/...-URL-er fungerer på samme måte som dine egne samtaler. Nyttig for å arkivere en tråd noen delte med deg.
• Claude Computer Use-økter. Begrenset til det som er synlig i DOM-en --- skjermbilder og modellens resonnement kommer gjennom, den underliggende VM-tilstanden gjør det ikke.
• Claude Code-samtaler. Claude Code kjører i terminalen din, ikke i claude.ai. For terminaløkter, se Claude Code + Obsidian workflow-guiden for å fange dem separat.

Par den med arbeidsflyten din

Markdown-utdataen fungerer overalt du trenger den:

• ChatGPT / Gemini / lokale modeller --- lim inn filen, still oppfølgingsspørsmål mot en annen modell
• Obsidian --- slipp den i vault-en din, lenk den fra prosjektnotater, søk på tvers av hver Claude-tråd du noen gang har lagret
• Notion --- lim inn direkte, overskrifter og Artifact-kodeblokker rendres korrekt
• Apple Notes --- ren import via Markdown-delingsutvidelsen
• Et git-repo --- commit Artifacts rett fra kodeblokkene inn i riktig fil
• Save Vault --- hvis du har koblet til en, lander hver Claude-lagring der automatisk med bakoverlenker og tagger

FAQ

Fungerer Save på delte samtalelenker? Ja. Alt på claude.ai/share/... eksporteres på samme måte som dine egne samtaler. Nyttig for å arkivere tråder kolleger sender deg.

Hva med Claude Projects? Hver samtale inne i et Project lagres individuelt. Når Projectets system prompt eller kunnskapsfiler er synlige på siden (overskrift eller sidefelt), fanger Save dem i frontmatteren slik at du ikke mister konteksten samtalen var avhengig av.

Fanger den Artifacts? Ja --- dette er kjernedifferensiatoren. Artifacts (kode, dokumenter, HTML, React-komponenter, Mermaid-diagrammer) kommer gjennom som kodeblokker med riktig språkidentifikator, i rekkefølgen Claude bygde dem. Du kan kopiere dem direkte inn i et repo eller et dokument.

Hva med sitater fra Claudes websøk? Sitater bevares som Markdown-fotnoter. Fotnotens tekst er kilde-URL-en, så du kan revidere Claudes grunnlag senere uten å gå tilbake til den opprinnelige tråden.

Vil det fungere i Claude Code (CLI-en)? Claude Code kjører i terminalen din, ikke i nettleseren. Utvidelsen retter seg mot claude.ai. For CLI-økter lever samtaletranskripsjonen på disk i ~/.claude/ og kan fanges separat --- Claude Code + Obsidian workflow-guiden dekker det.

Håndterer den veldig lange tråder? Ja. Claudes 200K-kontekst kan produsere samtaler med hundrevis av turer. Save ruller samtalepanelet og leser hver tur når den virtualiseres tilbake til DOM-en, så selv de lengste trådene kommer gjennom komplette.

Inkluderes forgrenede svar? Bare grenen som for øyeblikket vises i UI-en (den du beholdt). Regenererte grener du ikke valgte hoppes over så filen matcher samtalen som Claude viser den til deg.

Hva koster det? Save har et gratis nivå så du kan prøve det på et par samtaler. Etter det dekker et lite abonnement løpende bruk.

Relaterte Save-guider

• Lagre ChatGPT-samtaler som Markdown --- hver tur, med kodeblokker intakt
• Lagre YouTube-videoer som Markdown --- AI-transkripsjon, sammendrag, tidsstempler
• Lagre GitHub-repoer og issues som Markdown --- README, issues, PR-diskusjoner, alt som én fil
• Claude Code + Obsidian Knowledge-Base Workflow --- fange terminaløkter og bygge et søkbart arkiv

Footnotes

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