Batch Request File Builder for AI APIs (JSONL)

About the Batch Request File Builder for AI APIs (JSONL)

Batch processing runs thousands of AI requests at half the usual price, but each request has to be one line of a JSONL file in the exact shape the API expects — and the answers come back in another file, in any order, matched only by an id. This builder does both ends from a spreadsheet.

Open a CSV, TSV, Excel or OpenDocument sheet (or paste cells), write a prompt template with {{column}} placeholders and an optional system prompt, choose the model id, the output limit, the temperature and — for structured output — a JSON Schema, and pick the request format: the chat-completions format (custom_id, method, url and body), the messages format (custom_id and params) or the generate-content format (key and request). Every row is checked, each request gets a stable id, the tokens are counted with the LLM Token Counter’s tokenizers, and the cost is estimated at the batch prices you enter or pick; a batch over the format’s limits is split into several files.

When the batch has run, open its results here: the answers, finish reasons, token use and errors become new columns of your sheet, structured answers are checked against the schema and spread into their own columns, and the rows that failed go into a retry file. Nothing is sent anywhere and no API key is asked for. Without a pass the result is a free preview: the validation report of every row with the token and cost estimate and the first lines of the batch file (up to 5, and at most half of a small batch); the files, splitting, result merging and retry files unlock with a Premium pass.

Common uses

• Classifying, tagging or summarising thousands of rows — reviews, tickets, product descriptions — at batch prices.
• Extracting fields from text into columns with structured output and a schema.
• Running an evaluation set through a model and getting every answer next to its row.
• Re-sending only the rows that failed or expired, with the same ids.

The three formats and their limits

• Chat-completions format: one line per request with custom_id, method (POST), url (/v1/chat/completions) and body; structured output goes in response_format as a json_schema with strict: true. Up to 50,000 requests and 200 MB per input file, with a 24-hour completion window. Results come back as lines with custom_id, response (status_code and body) and error; failed and expired requests are written to a separate error file, so open both.
• Messages format: each request is custom_id and params; ids match ^[a-zA-Z0-9_-]{1,64}$. Up to 100,000 requests or 256 MB per batch; a batch that does not finish within 24 hours expires. Results are lines with custom_id and a result of type succeeded, errored, canceled or expired. The API takes the requests as one JSON body ({"requests": […]}), which the builder can also write; structured output is output_config.format with a json_schema.
• Generate-content format: one line per request with key and request (a generateContent request: contents, systemInstruction, generationConfig; structured output as responseMimeType application/json with responseJsonSchema). Input files may be up to 2 GB; the target is 24 hours and jobs expire after 48. The model is chosen when the job is created, not in each line.

All three are billed at half the standard price, and all three may return results in any order, so the builder matches every result to its row by its id.

How the results are merged

Each result is matched to its row by custom_id or key. The answer text, the finish reason, the input and output tokens and any error go into new columns; a row with no result yet is marked missing. With a schema, the answer is read as JSON (also inside a ``json fence), checked against the schema, and each top-level field gets its own column, with any schema errors in schema_errors`. Errored, expired, canceled and missing rows and answers that break the schema go into the retry file with their original ids. Cells that a spreadsheet would read as a formula (starting with =, +, -, @, a tab or a carriage return) are written with a leading apostrophe, so an answer can never run as a formula when the file is opened.

Sources

• Batch guide for the chat-completions format — line format, limits and results
• Batch processing for the messages format — request shape, id rules, limits and result types
• Structured outputs for the messages format — output_config.format
• Batch mode for the generate-content format — key and request lines, limits and results
• OWASP: CSV injection — why formula cells are neutralised

Limitations

• The builder writes and reads files; it does not submit batches or fetch their results (that needs your API key, which this page never asks for).
• Token counts for model families that publish no tokenizer are estimates, and the cost uses the prices you enter or pick, at the batch rate; long-context surcharges and cache prices are not included.
• Each request is one user turn with an optional system prompt; tools, images and multi-turn conversations are not built here.
• Sheets of up to 200,000 rows are read; counting the tokens of very large sheets takes a while.

Privacy

On this device; its files download once

Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot. Counting tokens downloads the tokenizer you pick once from MySmartCoPilot; your sheet, prompts and results never leave the browser, and no API key is ever asked for.