ChatGPT vs Claude vs Gemini: How Their Export Formats Differ
If you use more than one AI assistant, you've probably noticed that exporting your data from each platform gives you a completely different file format. Here's a detailed comparison of what ChatGPT, Claude, and Gemini actually export, and why it matters. Export Format Overview | Feature | ChatGPT | Claude | Gemini | |-…
If you use more than one AI assistant, you've probably noticed that exporting your data from each platform gives you a completely different file format. Here's a detailed comparison of what ChatGPT, Claude, and Gemini actually export, and why it matters.
Export Format Overview
| Feature | ChatGPT | Claude | Gemini |
|---------|---------|--------|--------|
| Export method | Settings → Data Controls | Settings → Privacy | Google Takeout |
| File format | Single JSON file | Single JSON file | Multiple JSON files |
| Message structure | Tree (parent-child nodes) | Flat array | Flat array with parts |
| Timestamps | Unix (seconds) | ISO 8601 | ISO 8601 |
| Branching support | Yes (tree structure) | No | No |
| Includes system prompts | Yes | No | No |
| File per conversation | No (all in one) | No (all in one) | Yes (one per conversation) |
| Archive format | ZIP with multiple files | Single JSON | ZIP via Google Takeout |
ChatGPT's \conversations.json\ is the hardest to parse because conversations are stored as directed trees, not linear message lists.
\\\`json
{
"mapping": {
"node_001": {
"message": {
"author": { "role": "user" },
"content": { "parts": ["Hello"] }
},
"parent": null,
"children": ["node_002"]
},
"node_002": {
"message": {
"author": { "role": "assistant" },
"content": { "parts": ["Hi there!"] }
},
"parent": "node_001",
"children": ["node_003", "node_004"]
}
}
}
\\\`
Why it's a tree: When you edit a message or click "Regenerate," ChatGPT creates a new branch. The tree preserves all branches, not just the one you're currently viewing. This means a single conversation can have dozens of message paths.
Parsing challenge: You need to traverse from root to leaf, choosing the correct branch at each node. Most scripts just take the last child, which usually gives you the most recent version, but not always.
Claude: The Simplest Format
Claude's export is the most straightforward. Conversations are stored with a flat message array:
\\\`json
{
"uuid": "abc-123",
"name": "My Conversation",
"chat_messages": [
{ "sender": "human", "text": "Hello" },
{ "sender": "assistant", "text": "Hi there!" }
]
}
\\\`
Why it's simpler: Claude doesn't expose branching in exports. If you edited a message and regenerated, only the final version appears. This makes parsing trivial: just iterate through the array.
The catch: While the structure is simple, the \text\ field contains raw markdown. If you just dump it to a text file, you'll see \bold\ and \## headings\ as literal characters instead of formatted text.
Gemini: The Most Fragmented Format
Gemini's export is unique because it comes through Google Takeout and creates one file per conversation:
\\\`json
{
"conversation": {
"title": "My Chat",
"messages": [
{
"role": "user",
"parts": [{ "text": "Hello" }]
},
{
"role": "model",
"parts": [{ "text": "Hi there!" }]
}
]
}
}
\\\`
Why it's fragmented: Google Takeout is a generic data export tool, not purpose-built for Gemini. It exports each conversation as a separate file inside a nested folder structure.
The catch: The \parts\ array can contain text, images (as base64), function calls, or empty entries. You can't just grab \parts[0].text\ without checking what type of part it is.
Why the Differences Matter
For DIY Parsing
If you're writing your own scripts, you essentially need three different parsers: The tree traversal for ChatGPT alone is a significant engineering task. Supporting all three platforms means maintaining three codebases that handle different edge cases.
For Data Portability
There's no standard format for AI conversation data. You can't take a ChatGPT export and import it into Claude, or vice versa. Each platform has its own internal data model, and that's what you get when you export.
For Long-Term Archiving
If you're archiving conversations for reference, having three different JSON formats in three different structures makes searching and organizing nearly impossible. Converting everything to a standard document format (Word, PDF, Markdown) normalizes the data.
The Solution: Convert Everything to Documents
Rather than dealing with three different JSON formats, convert all your exports to a standard document format:
ChatExports auto-detects the format and parses it correctly
Export everything as Word, PDF, or Markdown
The result: all your AI conversations from every platform, in the same readable format, organized by date and title.
What You Get
Consistent formatting across all platforms
Searchable documents instead of raw JSON
Proper rendering of code blocks, headings, bold, lists
Bulk export to download everything as a ZIP
Browser-only processing: your data never leaves your device
Future-Proofing Your Data
AI platforms will change their export formats over time. OpenAI has already modified their JSON structure multiple times. By converting to standard document formats now, you protect your data from future format changes.
A Word document from 2026 will still be readable in 2036. A proprietary JSON format from a startup that might not exist in 10 years? That's a gamble.