Como salvar uma conversa do Claude como Markdown (Artifacts, citações, Projects)

As conversas do Claude são cada vez mais o lugar onde pesquisa séria e trabalho de código acontecem. Threads longas com Artifacts, citações e idas e vindas de várias horas frequentemente contêm mais raciocínio do que qualquer documento nas suas anotações. E ainda assim, a Anthropic não oferece nenhuma exportação. Não há botão de “baixar como Markdown”, nem dump JSON, nem endpoint de arquivo. Uma vez que uma thread saia da sua barra lateral, a única forma de voltar é uma busca no claude.ai que nem sempre traz o que você lembra.

Salvar conversas do Claude como Markdown resolve três coisas de uma vez: você obtém um arquivo local permanente, pode referenciar raciocínios passados dentro do Obsidian ou Notion, e pode devolver uma thread antiga do Claude para o ChatGPT ou Gemini como contexto quando trocar de modelo.

Este guia cobre todos os métodos para converter uma conversa do Claude em Markdown limpo --- desde um chat rápido até uma thread de pesquisa de 200K tokens com Artifacts.

Por que salvar conversas do Claude como Markdown?

Markdown é o formato que funciona em qualquer lugar que uma conversa precise ir:

• Entregue para outro LLM --- cole uma thread antiga do Claude no ChatGPT, Gemini ou um modelo local quando quiser uma segunda opinião ou um estilo de raciocínio diferente
• Coloque no Obsidian ou Notion --- um arquivo por conversa, totalmente pesquisável, linkável a partir de notas de projeto
• Cite um turno específico --- encontrar “o momento em que Claude propôs o refactor” em uma thread de 50 turnos está a uma busca de distância
• Arquive Artifacts como arquivos reais --- o código, o doc, o componente React que Claude construiu vira um bloco de código que você pode copiar para um repo
• Preserve citações --- resultados de busca na web nos quais Claude fundamentou sua resposta viram notas de rodapé que você pode auditar depois

O caso de uso que move a maior parte do tráfego Claude-para-Markdown em 2026 é o primeiro: as pessoas usam Claude para trabalho profundo, depois querem manter a saída e o raciocínio, não só a resposta final.

Método 1: Save (mais rápido, um clique)

Save é uma extensão do Chrome que transforma qualquer conversa do Claude em um arquivo Markdown com um clique. Ela percorre o DOM da conversa, extrai cada turno do usuário e do assistente em ordem, puxa os Artifacts como blocos de código com o identificador de linguagem correto, e preserva citações como notas de rodapé.

Como funciona:

1. Abra a conversa do Claude no Chrome (funciona em claude.ai/chat/... e em links de conversa compartilhada)
2. Clique no ícone da extensão Save na sua barra de ferramentas
3. Um arquivo .md é baixado instantaneamente (ou cai no seu Save Vault se conectado)

O que você obtém:

• Título da conversa e data como frontmatter
• Cada turno do usuário e do assistente, em ordem, com rótulos de papel (## You / ## Claude)
• Artifacts do Claude (código, documentos, HTML, componentes React) extraídos como blocos de código com o identificador de linguagem correto
• Blocos de código dentro das respostas com hints de linguagem preservados
• Citações dos resultados de busca na web do Claude como notas de rodapé Markdown
• Turnos de uso de ferramentas capturados quando Claude chama uma ferramenta (a chamada e o resultado aparecem ambos)
• Contexto do Project preservado quando a conversa está dentro de um Claude Project e o system prompt ou os arquivos de conhecimento estão visíveis

O que é removido:

• Chrome de navegação, barra lateral, seletor de modelo do Claude.ai
• Branches regenerados vazios que você não escolheu
• Affordances de UI inline (botões “Edit”, “Copy”, “Retry”)
• Esqueletos de carregamento e streams parciais

Ideal para: Pesquisadores, engenheiros, usuários de IA, qualquer um que mantenha threads longas no Claude e queira manter o trabalho. Se você precisa de um transcript limpo para colar em outro modelo, arquivar no Obsidian ou passar para um colega, este é o caminho mais limpo.

Exemplo de saída

Salvar uma conversa curta do Claude com um Artifact produz:

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

Esse arquivo está a um colar de distância de ser contexto utilizável para ChatGPT, a um pressionar de tecla de ser uma nota permanente no Obsidian, e o Artifact dentro dele está a uma cópia de ser commitado para um repo.

## Método 2: copiar-colar manual

Claude.ai permite que você selecione texto no painel da conversa e copie como qualquer página da web.

**Passos:**

1. Role até o topo da conversa
2. Clique e arraste para selecionar cada turno
3. Copie, cole em um editor Markdown
4. Adicione manualmente rótulos de papel, conserte os delimitadores de blocos de código, adicione de volta o conteúdo dos Artifacts que não veio, reconstrua os links de citação

**Problemas com essa abordagem:**

- Selecionar a conversa completa em uma thread longa é frágil --- Claude virtualiza o DOM, então rolar derruba turnos anteriores do documento
- Artifacts não copiam como texto; você recebe um placeholder ou nada
- Blocos de código perdem seus hints de linguagem
- Citações de busca na web vêm como `[1]` `[2]` sem URL de destino
- Limites de papel colapsam --- turnos do usuário e do Claude se misturam em uma parede de texto
- Conversas ramificadas (onde você regenerou uma resposta) trazem todos os branches de uma vez

Viável para uma troca de 2 turnos. Desmorona em qualquer coisa mais longa do que uma tela.

## Método 3: console do navegador + script

Para desenvolvedores, os dados da conversa vivem no DOM. Você pode escrever um script pequeno no console do Chrome DevTools para percorrê-lo.

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

Ideal para: Engenheiros que querem controle pontual sobre a saída, ou que precisam scriptar extração em massa em muitas threads.

Problemas com essa abordagem:

• Os seletores não fazem parte de nenhuma API pública; Anthropic lança mudanças de UI regularmente e o script quebra sem aviso
• Artifacts são renderizados dentro de iframes ou portais React fora da árvore; innerText os perde
• Citações vivem em tooltips que não estão no DOM inicial
• Turnos de uso de ferramentas são aninhados diferentemente de turnos de texto
• Você precisa estar logado e na aba da conversa; não funciona como job em lote

Uma saída razoável quando você controla o ambiente. Não um método para confiar.

Método 4: Workbench API da Anthropic (reconstruindo conversas)

A API da Anthropic expõe primitivas de conversa através do endpoint Messages, mas não há endpoint que retorne suas conversas passadas no claude.ai. A API só vê conversas que você enviou através dela. Para reconstruir uma thread do claude.ai programaticamente, você precisaria replayá-la você mesmo.

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

Ideal para: Equipes construindo seus próprios wrappers do Claude que armazenam conversas em seu próprio banco de dados. Se você controla as chamadas, você controla a exportação.

Problemas para o caso de uso de conversa-existente:

• Conversas passadas do claude.ai não são alcançáveis pela API
• Requer créditos de API e sua própria camada de armazenamento
• Não ajuda a arquivar uma thread que você já tinha na UI web
• Artifacts também são um recurso da API, mas o pipeline de renderização é o do app web, não da API

Este é o método certo se você está construindo um produto. É o método errado se você está tentando arquivar a thread de pesquisa de ontem.

Qual método você deve usar?

Cenário	Melhor método
Arquivar uma thread de pesquisa do Claude que você já tinha	Save --- um clique, saída estruturada
Colar uma conversa antiga do Claude no ChatGPT ou Gemini	Save --- cada turno, Artifacts intactos
Manter um Artifact (código, doc, React) que Claude construiu para você	Save --- extraído como bloco de código
Colocar uma thread no Obsidian ao lado de notas de projeto	Save --- frontmatter e títulos limpos
Construir seu próprio logger de conversa do zero	API Anthropic --- se você controla as chamadas
Cópia rápida e bruta de uma troca de 2 turnos	Copiar-colar manual --- grátis, rápido, bagunçado
Extração pontual com transformações customizadas	Script de console --- se você está confortável com seletores

Para a maioria das pessoas --- especialmente qualquer um usando Claude para pesquisa, engenharia ou escrita --- Save é a resposta. Produz o Markdown mais limpo sem nenhum setup, e lida com threads de 200K tokens na mesma velocidade que um chat de um turno.

Casos extremos que o Save lida

• Claude Projects. Cada conversa dentro de um Project é extraída como arquivo autônomo. Quando o system prompt ou arquivos de conhecimento do Project estão visíveis no cabeçalho da conversa, Save os captura no frontmatter para que o contexto não se perca.
• Conversas multi-Artifact. Threads onde Claude construiu três Artifacts (ex. uma página HTML, um componente React e um schema SQL) saem com cada Artifact como seu próprio bloco de código, na ordem em que apareceram, com o identificador de linguagem correto.
• Conversas muito longas. A janela de contexto de 200K do Claude pode produzir threads com centenas de turnos e dezenas de milhares de palavras. Save transmite o DOM enquanto rola, então a thread completa passa sem perder turnos anteriores.
• Respostas ramificadas e regeneradas. Quando você regenerou uma resposta do Claude, apenas o branch que você manteve (o atualmente mostrado) é exportado. Branches descartados são pulados.
• Turnos de uso de ferramentas. Quando Claude chama uma ferramenta --- busca na web, execução de código, computer use --- tanto a chamada quanto o resultado são capturados como blocos de código com marcadores tool_use e tool_result para que a cadeia de raciocínio fique intacta.
• Links de conversa compartilhada. URLs claude.ai/share/... funcionam da mesma forma que suas próprias conversas. Útil para arquivar uma thread que alguém compartilhou com você.
• Sessões de Computer Use. Limitado ao que está visível no DOM --- os screenshots e o raciocínio do modelo passam, o estado subjacente da VM não.
• Conversas do Claude Code. Claude Code roda no seu terminal, não em claude.ai. Para sessões de terminal, veja o guia de workflow Claude Code + Obsidian para capturá-las separadamente.

Combine com seu workflow

A saída Markdown funciona onde você precisar:

• ChatGPT / Gemini / modelos locais --- cole o arquivo, faça perguntas de acompanhamento para um modelo diferente
• Obsidian --- coloque no seu vault, linke a partir de notas de projeto, busque em cada thread do Claude que você já salvou
• Notion --- cole diretamente, títulos e blocos de código de Artifacts renderizam corretamente
• Apple Notes --- importação limpa via a extensão de compartilhamento Markdown
• Um repo git --- commite Artifacts direto dos blocos de código para o arquivo certo
• Save Vault --- se você conectou um, cada save do Claude cai lá automaticamente com backlinks e tags

FAQ

Save funciona em links de conversa compartilhada? Sim. Qualquer coisa em claude.ai/share/... é exportada da mesma forma que suas próprias conversas. Útil para arquivar threads que colegas enviam para você.

E sobre Claude Projects? Cada conversa dentro de um Project é salva individualmente. Quando o system prompt ou arquivos de conhecimento do Project estão visíveis na página (cabeçalho ou barra lateral), Save os captura no frontmatter para que você não perca o contexto do qual a conversa dependia.

Captura Artifacts? Sim --- este é o diferenciador central. Artifacts (código, documentos, HTML, componentes React, diagramas Mermaid) passam como blocos de código com o identificador de linguagem correto, na ordem em que Claude os construiu. Você pode copiá-los diretamente para um repo ou documento.

E sobre citações da busca web do Claude? Citações são preservadas como notas de rodapé Markdown. O texto da nota é a URL fonte, então você pode auditar o grounding do Claude depois sem voltar para a thread original.

Vai funcionar no Claude Code (a CLI)? Claude Code roda no seu terminal, não no navegador. A extensão alveja claude.ai. Para sessões CLI, o transcript da conversa vive no disco em ~/.claude/ e pode ser capturado separadamente --- o guia de workflow Claude Code + Obsidian cobre isso.

Lida com threads muito longas? Sim. O contexto de 200K do Claude pode produzir conversas com centenas de turnos. Save rola o painel da conversa e lê cada turno conforme se virtualiza de volta no DOM, então até as threads mais longas passam completas.

Respostas ramificadas são incluídas? Apenas o branch atualmente mostrado na UI (o que você manteve). Branches regenerados que você não escolheu são pulados para que o arquivo combine com a conversa como Claude a mostra para você.

Quanto custa? Save tem uma camada gratuita para você experimentar em algumas conversas. Depois disso, uma pequena assinatura cobre o uso contínuo.

Outros guias Save

• Salvar conversas do ChatGPT como Markdown --- cada turno, com blocos de código intactos
• Salvar vídeos do YouTube como Markdown --- transcript IA, resumo, timestamps
• Salvar repos e issues do GitHub como Markdown --- README, issues, discussões de PR, tudo em um arquivo
• Workflow Claude Code + Obsidian como base de conhecimento --- capturando sessões de terminal e construindo um arquivo consultável

Footnotes

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