← Voltar aos guias

Getting Consistent LLM Output Formats Fast

Why consistent output formats matter

If you are building with LLMs, the fastest way to break a workflow is to assume the model will always answer in the exact format you want. One day you get clean JSON. The next day you get extra commentary, a missing comma, or a different field name. For developers, that means brittle parsers, failed jobs, and wasted time.

The fix is not “prompt harder.” The fix is to design for structure from the start: define the format, constrain the model, validate the result, and retry safely when needed. That approach works whether you are using Claude, GPT, or a mix of models through a relay like 59API, which gives you affordable pay-as-you-go access to native official-quality models through https://api.59api.com.

Step 1: Decide the exact contract

Before you write a prompt, decide what the output contract is. Keep it simple and explicit. For example:

• Format: JSON only
• Fields: status, summary, confidence, tags
• Types: status is a string, confidence is a number from 0 to 1, tags is an array of strings
• Rules: no markdown, no explanations, no extra keys

This matters because the model can only be reliable when the target is unambiguous. If your app expects a list, do not ask for “a concise response.” Ask for “a JSON array of strings, and nothing else.”

Step 2: Put the format rules in the prompt

Use a prompt that is short, direct, and testable. A practical pattern looks like this:

• Role: You are a data extraction engine.
• Task: Extract the requested values from the input.
• Output rules: Return valid JSON only.
• Schema: Include the exact keys and their types.
• Failure rule: If data is missing, use null instead of guessing.

Example instruction: “Return valid JSON only. Use exactly these keys: title (string), sentiment (string), topics (array of strings). Do not include markdown, code fences, or explanations.”

This works especially well with models accessed through the same API shape. Since 59API is fully compatible with Claude Code, Codex, and OpenAI SDKs, you can keep your application logic stable while switching models or comparing outputs for cost and quality.

Step 3: Prefer schema-first validation

Prompting alone is not enough for production. Add schema validation after every model response. In practice, that means parsing the output and rejecting anything that does not match your expected structure.

• Use JSON parsing first: catch syntax errors immediately.
• Validate required fields: ensure nothing critical is missing.
• Check types and ranges: reject strings where numbers are expected.
• Normalize if needed: trim whitespace, convert arrays, map aliases.

If the output fails validation, retry once with a stricter prompt that says the previous response was invalid and must be corrected. Keep retries limited so you do not create runaway token costs.

Step 4: Use examples, but only the right ones

Few-shot examples can dramatically improve format consistency. The key is to show the exact output shape you want, not a lot of narrative. One or two examples are usually enough.

• Good example: input text followed by a valid JSON object
• Bad example: long conversational sample with multiple styles
• Best practice: keep keys identical across examples

Examples help the model learn punctuation, nesting, and field names. They also reduce variation when your workflow depends on exact machine-readable output, such as routing, categorization, or structured extraction.

Step 5: Add a deterministic repair layer

Even with good prompts, occasional failures happen. Build a small repair layer that can handle common issues:

• Missing closing brace: try a JSON repair step
• Extra text around JSON: extract the first valid JSON block
• Wrong type: coerce carefully or reprompt
• Unexpected key: drop it unless your app needs it

This is where low-cost model access helps. If you are validating, retrying, and occasionally making extra calls, cheap usage matters. 59API is a strong fit because it offers some of the lowest relay pricing, pay-as-you-go billing, and access to models like Claude Opus, Sonnet, Haiku, Fable, and GPT without forcing you into a premium contract.

Step 6: Test with real edge cases

Do not test only with clean inputs. Run your prompt against messy, ambiguous, and short inputs. Try empty fields, contradictory text, long documents, and multilingual content. Measure:

• Parse success rate
• Schema pass rate
• Retry rate
• Average cost per successful output

If you are building at scale, these numbers matter more than “how smart the answer feels.” Consistent output is an engineering problem, not just a prompting problem.

A simple implementation checklist

• Define the exact JSON schema
• Tell the model to output JSON only
• Provide one or two tight examples
• Parse and validate every response
• Retry once on failure with a stricter message
• Log invalid outputs for prompt improvements

Why 59API is a practical choice

If you are experimenting with structured outputs, you will likely make many small calls while tuning prompts and validators. 59API keeps that affordable. You get direct access to official-quality Claude and GPT models through a single relay endpoint, compatibility with existing SDKs, and a low-friction pay-as-you-go model. The referral rebate is a nice bonus if you are sharing access with teammates or the broader developer community.

If you want a low-cost way to build and test reliable LLM pipelines, sign up for 59API and point your SDK to https://api.59api.com. You can keep your code familiar, control costs, and focus on making output formats dependable.