ChatGPT Export Format Explained — What's Inside Your Data ZIP

What's in the ZIP file

When you extract the ChatGPT export ZIP, you'll find several files. The exact contents can vary slightly between exports but typically include:

conversations.json — the most important file. Contains your entire ChatGPT conversation history as a structured JSON array. This is what AI Chat Importer imports.

user.json — basic account information: your name, email address, and account creation date.

message_feedback.json — any thumbs up/thumbs down feedback you gave on ChatGPT responses.

model_comparisons.json — data from any A/B comparisons you participated in (most users will have an empty file here).

chat.html — in some exports, a basic HTML file that lets you browse your conversations in a browser. Useful for a quick look, but has no search and is slow with large archives.

For most purposes, conversations.json is the only file that matters.

Understanding the conversations.json structure

The conversations.json file is a JSON array — a list of conversation objects, one per chat. Here's what a simplified conversation object looks like:

{
  "id": "abc123",
  "title": "Python debugging help",
  "create_time": 1710000000,
  "update_time": 1710003600,
  "mapping": {
    "node-id-1": {
      "id": "node-id-1",
      "message": {
        "id": "msg-id-1",
        "author": { "role": "user" },
        "content": {
          "content_type": "text",
          "parts": ["Why is my loop not working?"]
        },
        "create_time": 1710000000
      },
      "parent": null,
      "children": ["node-id-2"]
    },
    "node-id-2": {
      "id": "node-id-2",
      "message": {
        "id": "msg-id-2",
        "author": { "role": "assistant" },
        "content": {
          "content_type": "text",
          "parts": ["The issue is likely..."]
        },
        "create_time": 1710000050
      },
      "parent": "node-id-1",
      "children": []
    }
  }
}

Key fields explained:

• id — a unique identifier for the conversation
• title — the conversation title as shown in the ChatGPT sidebar (auto-generated by ChatGPT)
• create_time — Unix timestamp (seconds since 1 January 1970) of when the conversation was created
• update_time — Unix timestamp of the last message
• mapping — the most complex part. This is a graph of message nodes, not a simple list.

Why the mapping structure is unusual

Most people expect conversation messages to be a simple array — message 1, message 2, message 3. ChatGPT's format uses a graph structure instead, where each message node has a parent and children array.

This is because ChatGPT supports branching conversations — if you edit a message and regenerate a response, the original response still exists in the export as a branch. The mapping structure preserves this full history.

What this means in practice:

• To reconstruct the main conversation thread, you need to traverse the graph from root to leaf following the active branch
• Messages with author.role: 'user' are your prompts
• Messages with author.role: 'assistant' are ChatGPT's responses
• Messages with author.role: 'system' are system prompts (usually invisible in the UI)
• The actual message text lives inside content.parts[] — an array, usually with one string element
• Some messages have null content — these are placeholder nodes in the graph and should be skipped

This is why the raw JSON is impractical to read manually — reconstructing a readable conversation from this graph requires writing code or using a tool that handles it for you.

Common issues with raw exports

A few things that catch people out when working with the raw export:

Timestamps are Unix seconds, not readable dates
1710000000 means nothing at a glance. You need to convert it — multiply by 1000 to get milliseconds, then use a date library or converter. 1710000000 = 9 March 2024, for reference.

The file can be very large
Heavy ChatGPT users can have exports over 100MB. Opening this in a text editor will be slow or crash the editor. A JSON viewer or dedicated tool handles it much better.

Not all messages have content
Some nodes in the mapping are structural placeholders with null or empty message fields. Any parser needs to handle these gracefully.

Branching conversations look confusing
If you edited a message mid-conversation, you'll see multiple children on a node. The “active” branch is typically the last child, but this isn't guaranteed in all cases.

Deleted conversations aren't included
ChatGPT's export only includes conversations that existed at the time of export. Conversations you deleted before requesting the export are gone permanently.

What AI Chat Importer does with this file

AI Chat Importer handles all of the complexity above automatically:

• Traverses the mapping graph and reconstructs the main conversation thread
• Converts Unix timestamps to readable dates
• Filters out placeholder nodes and system messages
• Renders message content from parts[] correctly
• Handles branching conversations by following the active branch

The result is a clean, readable, searchable conversation archive — all processed locally in your browser or on your desktop. Your raw JSON file never leaves your device.

Exporting from Claude and DeepSeek

If you use Claude or DeepSeek, their export formats are different from ChatGPT's:

Claude exports use a chat_messages array structure — simpler than ChatGPT's mapping graph, with straightforward sender/text fields per message.

DeepSeek exports vary by version but typically use a messages or history array structure, also simpler than ChatGPT's format.

AI Chat Importer supports all three formats. You can import exports from all three platforms into the same archive and search across them together.

See the export guides for each platform:

• How to export ChatGPT conversations →
• How to export Claude conversations →
• How to export DeepSeek conversations →