ShareGPT format: what data shape does it use?

MCQ·Easy·4.0 · 0·~1 min

Attempt it

**ShareGPT** is a community dataset format that became popular in 2023 because it originated from browser-extension exports of ChatGPT conversations. The shape reflects that history. Each example is one full multi-turn dialogue. The top-level field is `conversations` (or sometimes `conversation`), and its value is an array of message objects. Each message object has two fields: - `from`: one of `human` (user turn) or `gpt` (assistant turn). Some variants add `system` for a leading instruction. - `value`: the actual text of that turn. A typical ShareGPT example might look like: ``` {"conversations": [ {"from": "human", "value": "Explain transformers in one paragraph."}, {"from": "gpt", "value": "Transformers are neural networks that..."}, {"from": "human", "value": "Give a code example."}, {"from": "gpt", "value": "Here is a minimal example..."} ]} ``` The role labels are borrowed from the source platform: humans were typing, the GPT model was responding. Training stacks like Axolotl and LLaMA-Factory accept ShareGPT natively and convert it to whatever chat template the target base model expects (Llama 3 markers, ChatML, Mistral INST blocks).

**ShareGPT** is one of the foundational community dataset formats for instruction-tuned LLMs. Each example is a complete multi-turn dialogue stored under a `conversations` key, with each turn as a `{from, value}` object. **The role labels.** `from` is `human` for user turns and `gpt` for assistant turns. Some variants include a leading `{from: system, value: ...}` for behavioural setup. The naming comes directly from the ChatGPT browser extension that produced the original exports. **The structure of one example:** ``` {"conversations": [ {"from": "system", "value": "You are a helpful assistant."}, {"from": "human", "value": "What is RAG?"}, {"from": "gpt", "value": "Retrieval-augmented generation is..."} ]} ``` **Why the format spread.** ShareGPT.com was a community site where users posted interesting ChatGPT conversations. The browser-extension export shape became a de facto dataset format because thousands of such conversations were available for download, and dataset-cleaning teams curated them into training corpora (Vicuna, WizardLM, and others were trained on cleaned ShareGPT data). The format stuck for two reasons: it naturally handles multi-turn (a major weakness of earlier formats like Alpaca) and it predates the OpenAI chat-completions schema as a community standard. **Conversion to the standard chat format.** Modern training stacks treat ShareGPT as an input shape they convert internally. Axolotl, LLaMA-Factory, and TRL all read `conversations` arrays and re-emit them as `messages` arrays with `role` and `content` instead of `from` and `value`. The mapping is straightforward: `human` to `user`, `gpt` to `assistant`, `from` to `role`, `value` to `content`. **What ShareGPT is not.** Not Alpaca (which is single-turn flat fields like `instruction`, `input`, `output`). Not a preference format (no `chosen` and `rejected`). Not the legacy GPT-3 completion shape (no `prompt` and `completion`). It is purely SFT data in dialogue form.

Quick reference

TL;DR

ShareGPT is multi-turn dialogues stored as a `conversations` array of `{from, value}` objects, where `from` is `human` or `gpt` and `value` is the turn text.

Memory aid

Easy to grasp

Imagine someone installed a browser extension that captured every chat they had with an AI assistant and let them share the full back and forth with the world. Each shared file is one whole conversation, not just a single question and answer. Inside, the turns are listed in order, and each turn is tagged with who was talking. The two tags borrow the platform's own vocabulary: human for the person typing and gpt for the assistant responding. That captured-conversation shape is the ShareGPT format. The name is literal: people were sharing their GPT conversations, and the file shape mirrors what the extension exported.

Key concepts

ShareGPT format Alpaca format Instruction datasets Chat template

Detailed answer & concept explanation

~7 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Quick scan · 2–4 min

Everything important, quickly.

5 min: ShareGPT structure (conversations + from/value) + origin as ChatGPT exports + role labels human and gpt + which open-weight models trained on it + conversion to the standard chat format + comparison to Alpaca and DPO formats.

Side-by-side

Format	Multi-turn	Role field	Role values
ShareGPT	Yes	from	human, gpt, (system)
OpenAI chat	Yes	role	system, user, assistant, tool
Alpaca	No (single-turn)	N/A (flat fields)	N/A
DPO preference	No (response pair)	N/A	N/A

Real-world examples

Real products, models, and research that use this idea.

Vicuna (LMSys, 2023) was trained on around 70k cleaned ShareGPT dialogues, becoming the first major open chat-tuned model that approached ChatGPT quality.
WizardLM's early releases blended ShareGPT data with synthetic instruction-evolution data using the same conversations schema.
Axolotl's training config supports `type: sharegpt` directly, converting to the target model's chat template before training.
LLaMA-Factory ships a built-in ShareGPT data loader, common across community fine-tuning workflows.
Open-Assistant and similar conversational datasets are routinely available in ShareGPT format alongside the standard messages format.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QHow does a training stack convert ShareGPT to the standard chat format?

QWhy did the early open-weight community settle on ShareGPT instead of designing a new format?

QWhat quality issues come with raw ShareGPT data, and how do teams clean it?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Confusing ShareGPT with Alpaca. Alpaca is single-turn flat fields (instruction, input, output); ShareGPT is multi-turn dialogues as a conversations array of {from, value} objects.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.