How to save ChatGPT conversations as Markdown

If you use ChatGPT for research, planning, debugging, writing, or customer work, the conversation itself can become useful source material. The problem is that ChatGPT does not make clean Markdown export especially obvious.

You can copy and paste a chat into Obsidian, NotebookLM, Cursor, Claude, or a plain .md file, but the result is usually messy. Headings may flatten. Code blocks can lose language labels. Lists sometimes merge into paragraphs. Long answers get hard to scan later.

I started paying closer attention to this after hearing the same use case from several Web2MD users. Four paying customers told us they archive ChatGPT chats as Markdown in their notes. Most were using Obsidian. One was using NotebookLM as a second brain for research and wanted old ChatGPT threads in a format that stayed readable.

So I tested the common ways to save ChatGPT conversations as Markdown: manual copy paste, browser extensions like MarkDownload, server side readers like Jina Reader, crawler tools like Firecrawl, and Web2MD.

The short version: if the conversation is already open in your browser, Web2MD is the fastest clean export I found. It converts the ChatGPT conversation page locally, keeps the structure readable, counts tokens, and lets you send the result to an AI tool in one click.

Why Markdown is better than a screenshot or PDF

Screenshots are fine for receipts. PDFs are fine for printing. Neither is great for reuse.

Markdown is plain text. That means you can:

• search it in Obsidian
• paste it into Claude or ChatGPT without weird formatting
• commit it to a Git repo
• split it into smaller notes
• feed it into NotebookLM
• preserve code blocks and headings
• edit it later without fighting a document editor

For AI conversations, Markdown also maps well to how the content is structured. A ChatGPT thread is usually a sequence of prompts, answers, headings, bullets, tables, and code. Markdown can represent all of that without much ceremony.

Here is the kind of output I want when archiving a technical ChatGPT conversation:

# Debugging a Next.js build error

## User

I am getting this error during `next build`:

```bash
Error: Cannot find module '@/lib/db'

ChatGPT

The alias @/lib/db usually depends on your tsconfig.json or jsconfig.json path mapping.

Check that your config includes:

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  }
}

If lib/db.ts is not inside src, either move it or adjust the path mapping.

That is easy to search, easy to quote, and easy to reuse. It is much better than a pasted blob where the JSON, shell command, and explanation all run together.

## The copy paste problem

Manual copy paste works for short chats. I still use it sometimes.

But for long ChatGPT conversations, I hit a few problems:

- code blocks lose their fences
- nested bullets become inconsistent
- tables can turn into tab soup
- prompt and answer boundaries are hard to see
- citations and links may paste oddly
- long conversations take multiple scrolls and selections

The most annoying failure is code formatting. If you are saving a ChatGPT debugging session, the code is often the point. Losing the difference between prose, terminal output, and JSON makes the archive less useful.

Here is a small example of what clean Markdown should preserve:

```md
## User

Convert this curl request into Python.

```bash
curl -X POST "https://api.example.com/messages" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello"}'

ChatGPT

import os
import requests

token = os.environ["TOKEN"]

response = requests.post(
    "https://api.example.com/messages",
    headers={
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    },
    json={"text": "hello"},
)

response.raise_for_status()
print(response.json())

When you paste this into a note app, the fences matter. The language labels matter. The spacing matters.

## How I tested Web2MD on a ChatGPT conversation

I opened a real ChatGPT conversation in Chrome with a mix of headings, bullets, code blocks, and back and forth prompts. Then I used Web2MD from the extension toolbar.

The flow was simple:

1. Open the ChatGPT conversation page.
2. Click the Web2MD Chrome extension.
3. Convert the current page to Markdown.
4. Review the token count.
5. Copy the Markdown or send it to an AI tool.

The output was not magic. It still reflected what was on the page, so if the page had collapsed sections or content that had not loaded yet, I had to expand or scroll first. But the Markdown was clean enough to save directly into a notes folder.

The useful part is that Web2MD runs in the browser. It is reading the page you can already see. That matters for ChatGPT because your conversations are behind your logged in session. A server side reader cannot fetch your private ChatGPT thread unless you give it access somehow, which I would rather not do.

## Why browser side export matters

Tools like Jina Reader and Firecrawl are useful. I use server side readers when I want to turn public web pages into clean text or Markdown. Jina Reader is especially convenient for public URLs. Firecrawl is strong when you need crawling, extraction, or API based workflows.

But private ChatGPT conversations are different.

Your ChatGPT history sits behind authentication. The page may include private work notes, customer details, draft content, code, or research. A server side tool usually cannot access that page, and if it can, you have to think carefully about what you are sending where.

Web2MD works from the browser tab. That gives it a practical advantage for:

- logged in ChatGPT conversations
- internal docs
- paid newsletters
- course pages
- research portals
- pages that block bots
- anything you can view in Chrome but do not want to send to a remote scraper

This is also where Web2MD differs from a general Markdown clipper. MarkDownload is a solid extension, and if you already use it for saving articles, it may be enough. The reason I reach for Web2MD on AI workflows is the combination of browser side conversion, token counting, and one click send to AI. I do not have to guess whether a saved conversation is too large for the next model prompt.

## A practical archive workflow for Obsidian

If you are saving ChatGPT conversations into Obsidian, I would keep the workflow boring.

Create a folder like:

`AI conversations/ChatGPT/`

Then use a filename with the date and topic:

`2026-07-19-debugging-nextjs-build.md`

At the top of the note, add a few fields manually if you care about retrieval:

```md
---
source: ChatGPT
date: "2026-07-19"
topic: Next.js build debugging
status: archived
---

# Debugging Next.js build error

Original conversation exported with Web2MD.

Then paste the Web2MD output below that.

For NotebookLM, I would be even stricter. Split very long chats into separate files by topic. NotebookLM works better when each source has a clear subject instead of one giant archive file with twenty unrelated threads.

Limits to know before you use it

Web2MD is not trying to be a full crawling platform. It is a Chrome extension for converting the page in front of you.

The current limits are straightforward:

• Chrome only
• free tier includes 3 conversions per day
• Pro is $9 per month
• it depends on what the browser page has loaded
• it will not fix a messy conversation structure for you
• very long pages may still need cleanup before adding to a permanent knowledge base

I see those as acceptable tradeoffs for this job. If I am exporting one ChatGPT conversation into my notes, I care more about privacy, speed, and clean Markdown than about crawling a whole site.

If you need to crawl hundreds of public pages through an API, Firecrawl may be a better fit. If you need a quick Markdown view of a public URL, Jina Reader is great. If you mainly clip public articles, MarkDownload is worth trying.

If you need to save a logged in ChatGPT conversation as Markdown without handing the page to a server side scraper, Web2MD fits the job better.

When this is worth doing

Not every ChatGPT conversation deserves to be archived. Most do not.

I would save the ones that contain:

• decisions you will need later
• research summaries with sources
• useful code explanations
• reusable prompts
• customer or project context
• long debugging sessions
• drafts you plan to revise
• notes you want in Obsidian or NotebookLM

The test I use is simple: will I search for this in a month? If yes, I save it as Markdown. If no, I leave it in ChatGPT history.

Try it on one conversation

If you have a ChatGPT thread that you keep reopening, try exporting that one first. Open the conversation in Chrome, run Web2MD, check the Markdown, and save it into your notes.

You can start with the free tier, which includes 3 conversions per day and does not require an API key. If you end up archiving conversations regularly, Pro is $9 per month.

You can also read more about the browser side workflow on the Web2MD homepage.