How to Save a ChatGPT Conversation as Markdown (Every Turn, Code Blocks Intact)

ChatGPT conversations contain valuable insights --- the prompt that finally worked, the code block you’d rewrite from scratch otherwise, the research thread you spent two hours building. But they live trapped in OpenAI’s UI. There’s no real export per conversation, the share-link format strips most structure, and copy-paste destroys code formatting. Saving a ChatGPT conversation as Markdown lets you archive it, reference it, or feed it back to another model.

This guide covers every method to convert a ChatGPT conversation to clean Markdown --- from a quick one-turn answer to a thousand-turn research thread.

Why Save ChatGPT Conversations as Markdown?

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

• Feed it to another model --- Claude, Gemini, and local models all read Markdown natively, so a ChatGPT thread becomes context for the next prompt
• Drop it into Obsidian or Notion --- one file, fully searchable, properly headed, linked to related notes
• Build a prompt library --- save the conversations that worked, organized by task, reusable across projects
• Archive before it disappears --- deleted chats are gone forever, shared links can break, your knowledge shouldn’t depend on OpenAI’s UI
• Quote a specific turn --- finding “what did GPT say about the migration plan” in a 200-turn thread is one search away once it’s text

The use case driving most ChatGPT-to-Markdown traffic in 2026 is the first one: people want to hand a ChatGPT research thread to Claude or a local model and keep going, and pasting the share URL doesn’t work.

Method 1: Minibase (Fastest, One Click)

Minibase is a Chrome extension that turns any ChatGPT conversation into a Markdown file with one click. It walks the conversation DOM, preserves every turn in order, keeps code blocks with their language tags, and produces a file that reads like a real document, not a copy-paste dump.

How it works:

1. Open the ChatGPT conversation in Chrome (your own chat, a shared link, or a Custom GPT session)
2. Click the Minibase extension icon in your toolbar
3. A .md file downloads instantly (or lands in your Minibase Vault if connected)

What you get:

• Every user and assistant turn, in order, with role labels (## You / ## ChatGPT)
• Code blocks with their language identifiers preserved (typescript, python, bash, …)
• Tables, ordered and unordered lists, inline citations kept intact
• Mathematical notation rendered as LaTeX, not as broken Unicode
• Conversation title and created-date in the frontmatter
• Frontmatter with title, model, date, URL --- so the file is self-describing

What gets removed:

• ChatGPT sidebar, model picker, share button, and other UI chrome
• “Regenerate response” buttons and other interactive widgets
• Loading states from streamed responses (mid-token snapshots)
• Empty turns and aborted generations

Works on:

• Your own conversations at chatgpt.com (logged in)
• Shared conversation links (chat.openai.com/share/... and chatgpt.com/share/...)
• Teams and Enterprise conversations, if your browser has access
• Custom GPT conversations
• Project conversations with their pinned files referenced

Best for: Researchers, prompt engineers, AI users, students. If you need a clean ChatGPT export that you’ll paste into Claude or keep in Obsidian, this is the cleanest path.

Example Output

Saving a short ChatGPT conversation about Express + TypeScript produces:

---
title: "Building a REST API with Express and TypeScript"
model: GPT-4
date: 2026-05-22
url: https://chatgpt.com/c/68301f4a-...
---

## You

How do I set up an Express server with TypeScript and proper
error handling?

## ChatGPT

Here's a production-ready Express + TypeScript setup:

\`\`\`typescript
import express, { Request, Response, NextFunction } from 'express';

const app = express();
app.use(express.json());

app.get('/api/users/:id', async (req: Request, res: Response,
  next: NextFunction) => {
  try {
    const user = await findUser(req.params.id);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }
    res.json(user);
  } catch (err) {
    next(err);
  }
});

app.use((err: Error, req: Request, res: Response,
  next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Internal server error' });
});
\`\`\`

Key points:

1. **Type your handlers** --- use `Request`, `Response`, `NextFunction`
2. **Wrap async routes** --- always try/catch to forward errors
3. **Global error handler** --- catches anything routes miss

## You

What about validation on the request body?

## ChatGPT

Add a Zod schema and a middleware...

That file is one paste away from being usable Claude context, one keystroke away from being a permanent Obsidian note.

Method 2: ChatGPT’s Built-in Share + Export

OpenAI ships two official paths: per-conversation Share and account-wide Export.

Steps for Share:

1. Open the conversation, click Share, generate a link
2. Open the link in a private window
3. Use the browser’s “Minibase Page” or copy the visible text into a Markdown file by hand

Steps for Export:

1. Settings → Data Controls → Export data
2. Wait for OpenAI to email you a download link (can take hours)
3. Unzip the archive --- you get an HTML viewer plus a giant conversations.json file containing every chat you’ve ever had

Problems with this approach:

• Share-link HTML is not Markdown --- you still need to convert, and code blocks lose their language tags in the process
• Export gives you one giant JSON for the entire account, not one file per conversation
• The JSON schema is undocumented and changes without notice; parsing it cleanly is its own project
• Custom GPT sessions and project conversations sometimes don’t appear in the export at all
• Re-running the export pulls everything again --- there’s no incremental sync

Workable if you only need one or two conversations, or if you’re willing to write a JSON parser.

Method 3: Browser Extensions (SaveAsMyChat, etc.)

A handful of Chrome extensions specifically target ChatGPT export --- SaveAsMyChat, ChatGPT to Markdown, Superpower ChatGPT, and similar.

Best for: People who only ever export from ChatGPT and don’t care about other sources.

Problems for the cross-tool use case:

• Most are ChatGPT-only --- they don’t handle Claude, Gemini, or any non-AI page you might want to save
• Output quality varies a lot --- some lose code language tags, some flatten markdown tables, some inject the extension’s own branding into the file
• Many haven’t been updated for the current ChatGPT UI --- OpenAI changes the DOM regularly and single-purpose extensions break silently
• Some require you to manually click “Export” inside each conversation; not a one-click flow
• Maintenance and permissions are a gamble --- abandoned extensions still ship updates that ask for more access

If you only want ChatGPT, any of these can work. If you also save Reddit threads, YouTube videos, GitHub issues, and Notion pages, you’ll end up with five extensions doing what one should do.

Method 4: Copy-Paste Then Reformat

The lowest-tech option: select the conversation, copy, paste into a Markdown file, fix it by hand.

Steps:

1. Scroll to the top of the conversation
2. Select everything (Cmd+A inside the chat pane)
3. Paste into your editor
4. Re-add role headings, fix code block fences, restore lists that got flattened

Problems with this approach:

• Code blocks copy as plain text without language tags --- syntax highlighting is gone
• Tables become flat lines separated by tabs --- they have to be rebuilt by hand
• Inline math notation copies as broken Unicode
• Role labels (“You”, “ChatGPT”) don’t always come through the selection
• For anything over a dozen turns, the cleanup is longer than reading the conversation again

Useful for a single short answer. Falls apart on anything resembling research.

Which Method Should You Use?

Scenario	Best Method
Paste a ChatGPT thread into Claude or Gemini	Minibase --- one click, structured Markdown
Archive a research thread to Obsidian	Minibase --- frontmatter + clean turn structure
Build a prompt library across tools	Minibase --- same workflow for ChatGPT, Claude, anywhere else
Bulk-export your entire ChatGPT history	OpenAI Export --- the only path for “all conversations at once”
Share a single conversation as a public link	ChatGPT Share --- native, no install
Quick copy of a one-turn answer	Copy-paste --- fine for trivial cases

For most people --- especially anyone moving conversations between AI tools or keeping a serious archive --- Minibase is the answer. It produces the cleanest Markdown with zero setup, and it handles a thousand-turn thread the same way it handles a two-turn one.

Edge Cases Minibase Handles

• Very long conversations (1000+ turns). Minibase walks the full DOM and writes out every turn. The frontmatter includes the turn count so you can see the size at a glance. Long threads take a couple of seconds longer; the output stays clean.
• Conversations with images (DALL-E outputs, vision inputs). Generated images are linked back to their CDN URLs. Vision-input images uploaded by you are referenced with their position in the turn. The text content of the rest of the conversation is fully preserved either way.
• Multi-turn code generation with edits. When the assistant edits a previous code block (or you do), every version stays in the export in order, so you can see how the code evolved across the conversation.
• Custom GPT conversations. The Custom GPT’s name appears in the frontmatter. Tool calls (web browsing, file analysis, code interpreter) are flagged as such so you can tell when the assistant ran a tool vs. answered from training.
• Branched conversations (regenerated responses). ChatGPT lets you regenerate or edit and create a branch. Minibase exports the currently active branch --- the one visible in the UI when you click the extension --- not every alternate response.
• ChatGPT Memory references. When the assistant says “as we discussed earlier” and pulls from Memory, that’s stored in the model’s context, not in the page. Minibase can only export what’s on the page; Memory contents don’t appear in the file.
• O1 / o1-pro hidden reasoning chains. OpenAI doesn’t expose the full chain of thought for reasoning models --- it shows a summary. Minibase exports the summary that’s visible on the page, which is what the user sees. The raw hidden reasoning isn’t available to any client-side tool.

Pair It With Your Workflow

The Markdown output works wherever you need it:

• Claude / Gemini / local LLMs --- paste the file in, continue the conversation in a different model
• Obsidian --- drop it in your vault, link it to related notes, search across all your saved AI threads
• Notion --- paste directly, headings and code blocks render correctly, tables stay tables
• Apple Notes --- clean import via the Markdown share extension
• Minibase Vault --- if you’ve connected one, every ChatGPT save lands there automatically with backlinks and tags, alongside saves from every other source

FAQ

Does Minibase work on the ChatGPT mobile app? The extension is desktop Chrome only. On mobile, open the conversation in mobile Safari or Chrome, copy the share link, then save it from your desktop browser.

Can I save just one turn instead of the whole conversation? The default is the full conversation, because that’s what most people want. You can crop the file after by deleting the turns you don’t need --- it’s plain Markdown.

Does it work on shared links from someone else? Yes. Open the share link in your browser, click the extension, you get a Markdown file. You don’t need to be logged into ChatGPT for shared links.

What about Claude or Gemini conversations? Same extension. Minibase works on claude.ai and gemini.google.com the same way it works on ChatGPT --- the output uses model-specific role labels (## Claude, ## Gemini) but the file structure is identical.

Does it preserve the original conversation title? Yes. The title shown in the ChatGPT sidebar becomes the title field in the frontmatter and the filename. If you renamed the conversation, the rename is what gets saved.

Are code blocks really preserved with their language tags? Yes. ChatGPT marks language on its code blocks in the DOM (language-typescript, language-python, etc.) and Minibase reads that. Triple-backtick fences with the right language are what you get in the output.

Does it support Custom GPTs? Yes. The Custom GPT’s name appears in the frontmatter. Tool calls inside the conversation (browsing, code interpreter, file analysis) are marked so you can tell the difference between a normal answer and one that involved a tool.

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

Related Minibase Guides

• Save Claude Conversations as Markdown --- every turn, with artifacts and tool calls intact
• Save YouTube Videos as Markdown --- transcript, summary, chapter timestamps
• Save GitHub Repos and Issues as Markdown --- README, issues, PR discussions, all as one file
• Save Notion Pages as Markdown --- toggles expanded, databases as tables