Claude (Anthropic) Fine-Tune JSONL Validator

updated 30 May 2026 · AWS Bedrock · Claude 3 Haiku · separate pages for OpenAI, Gemini, Llama, Mistral

Anthropic Claude fine-tune JSONL validator. Validates the exact shape Bedrock's CreateModelCustomizationJob accepts for Claude 3 Haiku: a top-level system string, a messages array starting with user, strict user/assistant alternation, no extra keys. Runs in your browser, catches Bedrock's exact upload errors before you spend on a job.

Your training data never leaves this tab. Bedrock pulls your file from S3 when a job starts; this pre-flight check is fully local — useful for datasets with PII you don't want to debug twice.

⌨ Prefer the terminal? jsonlkit validate --anthropic data.jsonl — same checks, in a pipe.

What this tool does

It parses your fine-tune file one line at a time and checks each example against Anthropic's system + messages shape — the form AWS Bedrock accepts for Claude 3 Haiku customization. For every line it confirms the JSON parses, that messages is a non-empty array, that any top-level system is a string, that roles are user/assistant only and alternate, that the first turn is user, that at least one assistant turn exists, and that every content is a non-empty string (or an array of typed blocks). Failures are listed by line number; a summary tallies examples, valid count, average turns, and an approximate token total. It runs entirely in your browser.

The intent it closes: "I have a Claude fine-tune file and I need to know it will upload to Bedrock before I spend money on a job." Bedrock's pre-flight is minimal — most errors only surface after CreateModelCustomizationJob has been accepted and started — so catching a malformed line here saves a failed run and a debugging round-trip on data you may not want to re-handle.

When you'd reach for it

• Pre-flight before a Bedrock customization job. Paste or drop the file, click Validate, fix what's flagged before it costs you a started job.
• Catch the OpenAI-shape copy-paste mistake. A {"role":"system",…} entry inside messages is the single most common error — it's flagged immediately because Anthropic only allows user/assistant there.
• Confirm strict alternation. Two same-role turns in a row, or an assistant-first conversation, both fail the same way Bedrock fails them.
• Salvage a partly-broken file. Download valid examples only writes a clean file with the failing lines stripped.
• Sanity-check size and shape at a glance. The summary's example count and average-turns numbers tell you whether the dataset is what you expected.
• Work with sensitive data. Everything is local, so PII-laden training sets never leave the tab.

Where can I actually fine-tune Claude in 2026?

The single most important thing to know before you start: Anthropic's own API does not offer public fine-tuning. If you visit Anthropic's docs looking for a "fine-tune" endpoint, you'll be routed to a contact form for enterprise customers.

The only managed fine-tuning path for Claude in 2026 is Amazon Bedrock, and as of May 2026 the only Claude model with generally-available fine-tuning is Claude 3 Haiku, in the us-west-2 (Oregon) region.

• Not fine-tunable on Bedrock: Claude 3.5 Haiku, Claude Haiku 4.5, Claude Sonnet 3.5 / 4 / 4.x, Claude Opus 4 / 4.x.
• Not available through Anthropic's API directly — only through Bedrock's CreateModelCustomizationJob.
• After training you have to buy Provisioned Throughput to invoke the fine-tuned model — there's no on-demand inference for custom Claude models. Budget for it.

If you're trying to fine-tune Sonnet or Opus, the answer in 2026 is: you can't, on any managed platform. If you're trying to fine-tune via Anthropic directly, the answer is also: you can't.

The exact JSONL shape Bedrock accepts

Single-turn

{"system":"You are a helpful assistant.","messages":[
  {"role":"user","content":"what is AWS"},
  {"role":"assistant","content":"It is Amazon Web Services."}
]}

Multi-turn (verbatim from AWS docs)

{"system":"system message","messages":[
  {"role":"user","content":"Hello there."},
  {"role":"assistant","content":"Hi, how can I help you?"},
  {"role":"user","content":"what are LLMs?"},
  {"role":"assistant","content":"LLM means large language model."}
]}

Hard rules Bedrock enforces

• System is a top-level string, optional. Never {"role":"system", ...} inside messages.
• Minimum 2 messages. First message must be user; last must be assistant.
• Strict alternation. user → assistant → user → assistant… Two same-role turns in a row will fail.
• No extraneous keys. Anything outside system and messages at the top level, or outside role and content on a message, breaks upload.
• Content is a plain string for Bedrock training. Typed-block arrays ({"type":"text","text":"..."}) work in the runtime Anthropic API but are not the documented training shape.
• One JSON object per line. No blank lines, no trailing newline weirdness, no array wrapper.

What's NOT supported in Bedrock Claude training data

• Tool use. tool_use / tool_result blocks are not documented as supported in Claude 3 Haiku Bedrock fine-tuning. Training data must be plain text turns. (Tool use at inference on a fine-tuned model still works the same as the base model.)
• Vision / images. AWS docs explicitly call Claude 3 Haiku fine-tuning text-only. The "plans to introduce vision capabilities in the future" note is still in the docs as of May 2026.
• Typed content blocks. Bedrock examples use content as a plain string. The typed-block array form belongs to the inference API, not the training format.

How validation works

Parse, then check the shape

Each line is parsed as standalone JSON. A blank line is flagged as a problem, not skipped. A parse failure reports the line number and the parser message with a suggested fix. A line that parses is then checked against the Anthropic shape, and every structural problem on that line is listed separately so you see all of them at once rather than one-at-a-time.

What the structural check enforces

The example must be an object with a messages array of at least one entry. A top-level system, if present, must be a string — a {"text":…} object is rejected. Inside messages, each role must be the string user or assistant (so a system role here is invalid), the first message must be user, consecutive same-role turns are rejected, and at least one assistant turn must exist. Each content must be a non-empty string, or an array of typed blocks where each block has a string type (text blocks need a text string, image blocks need a source object).

What the local check does NOT enforce

This matters, so it's spelled out. The validator does not flag extraneous keys — an extra name on a message passes here even though Bedrock rejects it. It does not require the last message to be assistant (only that the first is user, roles alternate, and at least one assistant turn exists), and it does not enforce Bedrock's 2-message minimum, 32-record minimum, or per-record token cap. Typed-block content arrays pass the check even though Bedrock's documented training shape is plain strings. Treat a clean result as "syntactically Bedrock-shaped", not "guaranteed to pass every Bedrock server-side rule".

Summary and clean download

After a run the summary lists total examples, valid examples, average messages per example, an approximate total token count (characters ÷ 4), and total characters. The token figure is a rough estimate for sizing, not Claude's real tokenizer — use the token counter for an exact per-record count against the 32k cap. Download valid examples only rebuilds anthropic-fine-tune-clean.jsonl with the failing lines removed.

What this validator checks

• Each line is valid JSON, one object per line; blank lines are flagged.
• Top-level messages is present and is an array with at least one entry.
• Optional system is a string if present (not an object, not a message).
• No message inside messages has a role other than user / assistant (so role:"system" is flagged).
• The first message role is user.
• Roles strictly alternate user / assistant — no two same-role turns in a row.
• At least one assistant turn is present.
• Every content is a non-empty string, or an array of typed blocks (text / image). Typed-block arrays pass — Bedrock's documented training shape is plain strings, so prefer strings for Bedrock even though the check accepts arrays.

Example

A valid example

{"system":"You are a helpful assistant.","messages":[
  {"role":"user","content":"What is the capital of France?"},
  {"role":"assistant","content":"Paris."}
]}

Optional top-level system, a user turn, an assistant turn. Passes.

Mistakes this validator catches

{"messages":[
  {"role":"system","content":"..."},
  {"role":"user","content":"Hi"}
]}
// Flagged: role 'system' is invalid — Anthropic puts system at the top level.

{"messages":[
  {"role":"user","content":"Hi"},
  {"role":"user","content":"Two user turns in a row"}
]}
// Flagged: consecutive 'user' messages — roles must alternate.

{"messages":[
  {"role":"assistant","content":"I start the conversation."}
]}
// Flagged: first message must be 'user'.

{"system":{"text":"..."},"messages":[...]}
// Flagged: 'system' must be a string, not an object.

A mistake Bedrock catches but this validator does not

{"messages":[
  {"role":"user","content":"Hi","name":"bob"}
]}
// Passes locally, but Bedrock rejects the extraneous 'name' key.

The local check doesn't inspect for extra keys — strip anything outside role and content before uploading.

Recipes by intent

Convert an OpenAI dataset to the Bedrock shape

Move every {"role":"system",…} message to a top-level system string, drop any keys other than role and content, and make sure the conversation starts with user and alternates. Re-validate here, then upload.

Pre-flight a file you're about to push to S3

Validate, fix every flagged line, then Download valid examples only if you want a guaranteed-clean copy. Upload that to S3 and point CreateModelCustomizationJob at it with an IAM role that can read the bucket.

Check you're under the per-record token cap

The summary's token figure is a chars÷4 estimate only. For the real number against Bedrock's 32k-token-per-record limit, run the file through the token counter with the Claude preset.

Split a clean file for training and validation

Once the file validates, use the train / val / test splitter to carve out a validation set (Bedrock caps validation at 1 GB / 1,000 records).

Limits and performance

Bedrock's own limits for Claude 3 Haiku customization:

This page's own limits are your browser's memory: it handles whatever fits in RAM, typically up to ~1 GB on a laptop. Past ~50–100 MB the error list and textarea can lag; for multi-gigabyte files validate on the CLI (jsonlkit validate --anthropic). The error list renders the first 200 problems and notes how many more were found.

Errors and how to fix them

Real Bedrock error strings you'll see if a bad file slips past validation:

FAQ

Related tools

• OpenAI Fine-Tune ValidatorChat messages with tool_calls, vision, developer role, weight.
• Gemini Fine-Tune ValidatorVertex AI contents+parts, user/model.
• Llama Fine-Tune ValidatorLlama 3 chat, ShareGPT, Alpaca.
• Mistral Fine-Tune ValidatorOnline alternative to validate_data.py.
• Fine-tune dataset editorVisual editor; export to any provider format.
• Train / val / test splitterSplit a clean file 80/10/10 before training.
• Token counterPer-record Claude-tokenizer count against the 32k cap.