Ready to format
Paste JSONL data on the left and click Format Data
OpenAI
Alpaca
ShareGPT
// format & validate ai training data instantly
Format, validate and convert AI training datasets online. Supports JSONL, OpenAI Chat, Alpaca, ShareGPT, CSV formats — browser-based, free, no sign-up required.
Ready to format
Paste JSONL data on the left and click Format DataPaste your JSONL dataset or upload a .jsonl / .json file directly
Select input format (or use auto-detect) and your desired output format
Click Format Data to convert, or switch to Validate mode to check for errors
Copy output to clipboard or download as a .jsonl file ready for fine-tuning
Training Data Formatter is a free browser-based tool that helps AI developers prepare, validate, and convert training datasets for LLM fine-tuning. All processing happens client-side — your data never leaves your browser.
Supports the most common fine-tuning formats used by OpenAI, Hugging Face, and open-source LLM frameworks.
JSONL (JSON Lines) is a format where each line is a valid, self-contained JSON object. It's preferred for training data because it allows streaming large datasets without loading everything into memory — each training example is one line, making it easy to shuffle, split, and process in parallel.
OpenAI's fine-tuning format uses a messages array where each entry has a role (system, user, or assistant) and content. Example: {"messages": [{"role": "user", "content": "Hi"}, {"role": "assistant", "content": "Hello!"}]}. This is required for fine-tuning GPT-3.5 Turbo and GPT-4.
Alpaca format was introduced by Stanford for instruction-tuning datasets. Each record has instruction, optional input, and output fields. It's widely used for fine-tuning open-source models like LLaMA. Example: {"instruction": "Summarize this.", "input": "Long text...", "output": "Short summary."}
All formatting and validation is processed entirely in your browser using JavaScript. Nothing is uploaded or stored anywhere. The PHP backend only handles format detection — your actual dataset content never leaves your device. This makes it safe for proprietary or sensitive training data.
ShareGPT format uses a conversations array where each turn has from (human, gpt, or system) and value fields. It originated from the ShareGPT dataset and is commonly used with Vicuna, FastChat, and other open-source LLM training frameworks.
The tool handles datasets of any size since processing is done line-by-line. For very large files (50,000+ examples), we recommend uploading the file directly rather than pasting to avoid browser slowdowns. The tool will process all lines and display validation errors for any malformed entries.
This tool focuses on JSONL-to-JSONL format conversion (between OpenAI, Alpaca, ShareGPT schemas). For converting raw CSV to JSONL, use the CSV to JSON tool first, then paste the output here to reformat into your target training schema.
Validation mode checks that each line is valid JSON, verifies required fields exist for the selected format (e.g., messages for OpenAI, instruction/output for Alpaca), validates role values, and flags structural issues. It reports valid vs. invalid record counts and lists specific errors with line numbers.
A training data formatter is a tool that prepares, validates, and converts datasets used for fine-tuning large language models (LLMs). When training or fine-tuning AI models like GPT-3.5, GPT-4, LLaMA, Mistral, or Falcon, your dataset must conform to a precise schema specific to the training framework and model architecture. Even minor formatting errors — a missing field, wrong key name, or malformed JSON — can cause training jobs to fail silently or produce poorly-performing models.
The Training Data Formatter by JLV DevTools makes this process fast and reliable. Paste your raw JSONL dataset, select your input and output formats, and get a clean, validated, framework-ready dataset in seconds — all without uploading your data anywhere.
Different LLM training frameworks use different data schemas. OpenAI's fine-tuning API expects the Chat Completions message format. Hugging Face datasets for open-source models often use Alpaca or ShareGPT schemas. Using the wrong format will either cause API errors or result in a model that doesn't learn the intended behavior.
Beyond the top-level schema, subtle issues matter too: role names (user vs. human, gpt vs. assistant), field naming conventions (instruction vs. prompt), and whether multi-turn conversations are nested arrays or flat sequences. This tool handles all those conversions automatically.
OpenAI's current fine-tuning format for GPT-3.5 Turbo, GPT-4o Mini, and other models uses a messages array where each message object has a role and content. Valid roles are system, user, and assistant. The system message (optional) sets the model's persona. User and assistant messages alternate to form a conversation.
A well-formed OpenAI training example looks like:
{"messages": [{"role": "system", "content": "You are a concise writing assistant."}, {"role": "user", "content": "Summarize quantum computing in one sentence."}, {"role": "assistant", "content": "Quantum computing uses quantum bits to perform certain calculations exponentially faster than classical computers."}]}Each training example is one JSON object per line in a .jsonl file. OpenAI recommends at least 10 examples for fine-tuning, with 50–100 examples for most tasks and hundreds or thousands for complex behaviors.
The Alpaca dataset format, introduced by Stanford in 2023, became the de facto standard for instruction-following dataset construction in the open-source LLM community. It uses three primary fields: instruction (the task description), input (optional additional context), and output (the expected model response).
Alpaca format is used by many popular open-source training frameworks including Axolotl, LLaMA Factory, and FastChat. When the input field is empty, the prompt template typically just presents the instruction. When it contains data, it's appended to provide context.
ShareGPT format originated from the ShareGPT dataset — millions of conversations shared from ChatGPT — and is now widely used for training conversational models. It stores conversations as an array under the conversations key, where each turn has from (human, gpt, system) and value fields.
This format is natively supported by Vicuna, WizardLM, and most models trained with the FastChat framework. It's particularly well-suited for multi-turn conversation datasets where preserving the full dialogue context is important.
Running a fine-tuning job with a corrupted dataset wastes time and money. The Validation mode in this tool checks every line of your JSONL file for structural correctness:
The validator reports a summary of valid vs. invalid records and lists each issue with its line number, so you can fix problems before uploading to OpenAI, Hugging Face, or your training cluster.
Beyond format correctness, high-quality training data requires careful attention to content. A few guidelines:
When migrating existing datasets — from a Hugging Face dataset in Alpaca format to OpenAI's fine-tuning API, for example — manual conversion is tedious and error-prone. This tool automates format conversion while preserving all content. System prompts, multi-turn conversations, and optional fields are all handled correctly during conversion.
The auto-detect feature examines the structure of each line and infers the format automatically, making it easy to process datasets you've downloaded without knowing their exact schema.
Training datasets often contain proprietary data — internal documentation, customer support logs, domain-specific knowledge. Uploading this to a third-party service introduces privacy and security risks. This tool runs entirely in your browser: all formatting, validation, and conversion happens locally using JavaScript. Your data never leaves your device.
This makes the Training Data Formatter safe for use with confidential training data, GDPR-protected information, or any dataset where data residency matters.