**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.
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.
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.
Your training pipeline expects the OpenAI chat-completions schema natively and your data is already in that shape ShareGPT to messages conversion is extra glue; if your data is already in the modern format, stay there.
Your task is single-turn instruction-response with no conversational context ShareGPT's multi-turn structure is overhead for single-turn data; Alpaca or the flat chat shape is simpler.
Your data is preference pairs for DPO training ShareGPT has no chosen and rejected concept; preference data needs a different schema with explicit ordering.
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.
1Vicuna (LMSys, 2023) was trained on around 70k cleaned ShareGPT dialogues, becoming the first major open chat-tuned model that approached ChatGPT quality.
2WizardLM's early releases blended ShareGPT data with synthetic instruction-evolution data using the same conversations schema.
3Axolotl's training config supports `type: sharegpt` directly, converting to the target model's chat template before training.
4LLaMA-Factory ships a built-in ShareGPT data loader, common across community fine-tuning workflows.
5Open-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?
Sign in or go Pro to see the approach for this follow-up.
QWhy did the early open-weight community settle on ShareGPT instead of designing a new format?
Sign in or go Pro to see the approach for this follow-up.
QWhat quality issues come with raw ShareGPT data, and how do teams clean it?
Sign in or go Pro to see the approach for this follow-up.
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.