Batch processing

The Batch API lets you send groups of requests as a single job that processes asynchronously. This is useful when you need to run many requests and do not need immediate results — for example, running evaluations, generating embeddings for a large dataset, or classifying content in bulk.

How batches run

A batch processes its lines one at a time, so per-request latency sets its throughput: 1,000 lines that take 3 seconds each finish in about 50 minutes. Separate batches run in parallel, so split a large job across several batches to finish it sooner. Batch lines do not count against your API key’s rate limits. If your organization uses judge-based auto-routing, a line with model: "auto" still counts against the selected model’s own rate limits, and a line that exceeds them fails with rate_limit_exceeded. Batch requests are billed at the same rates as synchronous requests. Plan for each batch to finish within its 24-hour completion window. A batch that overruns is stopped and returns no results, even for lines that completed. Its status stays in_progress, so give your poller its own deadline.

Supported endpoints

Endpoint	Description
`/v1/responses`	Responses requests
`/v1/chat/completions`	Chat completion requests
`/v1/embeddings`	Embedding generation
`/v1/images/generations`	Image generation

All requests in a single batch must target the same endpoint.

Lifecycle

A batch moves through these statuses:

validating → in_progress → finalizing → completed
     ↓            ↓
   failed     cancelling → cancelled
                   ↓
                expired

Status	Description
`validating`	The input file is being checked for format and content errors.
`failed`	Validation failed — the input file contains errors. Check `batch.errors` for details.
`in_progress`	Requests are being processed.
`finalizing`	Requests have finished and results are being finalized.
`completed`	The batch finished. Download results from `output_file_id`.
`cancelling`	A cancel was requested. In-flight requests are finishing.
`cancelled`	The batch was cancelled. Partial results may be available.
`expired`	The batch exceeded its completion window and stopped.

Step 1 — Prepare the input file

Create a JSONL file where each line is one request. Every line has four fields:

Field	Type	Description
`custom_id`	string	Your identifier for this request. Used to match input to output. Must be unique within the file.
`method`	string	`"POST"` — the only supported method.
`url`	string	The endpoint path — must match the `endpoint` you declare when creating the batch.
`body`	object	The request body — the same parameters you would send to the synchronous endpoint.

{"custom_id": "request-1", "method": "POST", "url": "/v1/responses", "body": {"model": "auto", "input": "Summarize the benefits of batch processing in one sentence.", "store": false}}
{"custom_id": "request-2", "method": "POST", "url": "/v1/responses", "body": {"model": "auto", "input": "What is the capital of France?", "store": false}}
{"custom_id": "request-3", "method": "POST", "url": "/v1/responses", "body": {"model": "auto", "input": "Explain embeddings in one paragraph.", "store": false}}

Each body takes the same parameters as a synchronous Responses request, with these rules:

Leave out stream and background, or set them to false. A line that sets either one to true fails.
To set reasoning effort, send both keys of the reasoning object, for example "reasoning": {"effort": "low", "summary": null}. See Control reasoning.

These lines set store: false because the output file already holds each result. Leave it out if you also want to retrieve each response by ID later. A single batch can contain up to 10,000 requests. The input file can be up to 25 MB; a larger upload is rejected with HTTP 413.

Step 2 — Upload the input file

Upload the JSONL file using the Files API with purpose: "batch".

import { SDK } from '@meetkai/mka1';

const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

const file = await sdk.llm.files.upload({
  requestBody: {
    // Note: multipart uploads require a nonblank filename; the placeholder filename "blob" is treated as missing.
    file: new File([jsonlContent], 'batch_input.jsonl', { type: 'application/x-ndjson' }),
    purpose: 'batch',
  },
});

console.log(file.id);     // "file-abc123"
console.log(file.status); // "processed"

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: '<mka1-api-key>',
  baseURL: 'https://apigw.mka1.com/api/v1/llm/',
  defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
});

const file = await openai.files.create({
  // Note: multipart uploads require a nonblank filename; the placeholder filename "blob" is treated as missing.
  file: new File([jsonlContent], 'batch_input.jsonl', { type: 'application/x-ndjson' }),
  purpose: 'batch',
});

console.log(file.id);     // "file-abc123"
console.log(file.status); // "processed"

from meetkai_mka1 import SDK
import time
import json

sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

file = sdk.llm.files.upload(
    file={"file_name": "batch_input.jsonl", "content": open("batch_input.jsonl", "rb")},
    purpose="batch",
)

print(file.id)      # "file-abc123"
print(file.status)  # "processed"

using System.Text;
using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;

var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

var file = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
{
    File = new UploadFileFile()
    {
        FileName = "batch_input.jsonl",
        Content = Encoding.UTF8.GetBytes(jsonlContent),
    },
    Purpose = UploadFilePurpose.Batch,
});

Console.WriteLine(file.File!.Id);     // "file-abc123"

mka1 llm files upload \
  --file ./batch_input.jsonl \
  --purpose batch \
  -H 'X-On-Behalf-Of: <end-user-id>'

curl https://apigw.mka1.com/api/v1/llm/files \
  --request POST \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --form 'file=@batch_input.jsonl;type=application/x-ndjson' \
  --form 'purpose=batch'

Step 3 — Create the batch

Pass the uploaded file ID, the target endpoint, and the completion window.

const batch = await sdk.llm.batches.create({
  createBatchRequest: {
    inputFileId: file.id,
    endpoint: '/v1/responses',
    completionWindow: '24h',
    maxConcurrency: 4,
  },
});

console.log(batch.id);            // "batch_abc123"
console.log(batch.status);        // "validating" or "in_progress"
console.log(batch.requestCounts); // { total: 3, completed: 0, failed: 0 }

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: '/v1/responses',
  completion_window: '24h',
  max_concurrency: 4,
});

console.log(batch.id);              // "batch_abc123"
console.log(batch.status);          // "validating" or "in_progress"
console.log(batch.request_counts);  // { total: 3, completed: 0, failed: 0 }

batch = sdk.llm.batches.create(
    input_file_id=file.id,
    endpoint="/v1/responses",
    max_concurrency=4,
)

print(batch.id)              # "batch_abc123"
print(batch.status)          # "validating" or "in_progress"
print(batch.request_counts)  # { total: 3, completed: 0, failed: 0 }

var batch = await sdk.Llm.Batches.CreateAsync(new CreateBatchRequest()
{
    InputFileId = file.File!.Id,
    Endpoint = BatchEndpoint.RootV1Responses,
    MaxConcurrency = 4,
});

Console.WriteLine(batch.BatchObject!.Id);            // "batch_abc123"
Console.WriteLine(batch.BatchObject!.Status);        // "validating" or "in_progress"
Console.WriteLine(batch.BatchObject!.RequestCounts); // { Total: 3, Completed: 0, Failed: 0 }

mka1 llm batches create --body '{
  "input_file_id": "file-abc123",
  "endpoint": "/v1/responses",
  "completion_window": "24h",
  "max_concurrency": 4
}'

curl https://apigw.mka1.com/api/v1/llm/batches \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --data '{
    "input_file_id": "file-abc123",
    "endpoint": "/v1/responses",
    "completion_window": "24h",
    "max_concurrency": 4
  }'

You can also attach metadata for your own tracking:

const batch = await sdk.llm.batches.create({
  createBatchRequest: {
    inputFileId: file.id,
    endpoint: '/v1/responses',
    completionWindow: '24h',
    metadata: {
      description: 'nightly evaluation run',
      run_id: 'eval-2026-03-31',
    },
    maxConcurrency: 4,
  },
});

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: '/v1/responses',
  completion_window: '24h',
  metadata: {
    description: 'nightly evaluation run',
    run_id: 'eval-2026-03-31',
  },
  max_concurrency: 4,
});

batch = sdk.llm.batches.create(
    input_file_id=file.id,
    endpoint="/v1/responses",
    metadata={
        "description": "nightly evaluation run",
        "run_id": "eval-2026-03-31",
    },
    max_concurrency=4,
)

var batch = await sdk.Llm.Batches.CreateAsync(new CreateBatchRequest()
{
    InputFileId = file.File!.Id,
    Endpoint = BatchEndpoint.RootV1Responses,
    Metadata = new Dictionary<string, string>
    {
        { "description", "nightly evaluation run" },
        { "run_id", "eval-2026-03-31" },
    },
    MaxConcurrency = 4,
});

mka1 llm batches create --body '{
  "input_file_id": "file-abc123",
  "endpoint": "/v1/responses",
  "completion_window": "24h",
  "metadata": {
    "description": "nightly evaluation run",
    "run_id": "eval-2026-03-31"
  },
  "max_concurrency": 4
}'

Step 4 — Check batch status

Poll the batch until it reaches a terminal status.

const batch = await sdk.llm.batches.get({ batchId: 'batch_abc123' });

console.log(batch.status);                // "completed"
console.log(batch.requestCounts.completed); // 3
console.log(batch.requestCounts.failed);    // 0
console.log(batch.outputFileId);           // "file_xyz789"

const batch = await openai.batches.retrieve('batch_abc123');

console.log(batch.status);                  // "completed"
console.log(batch.request_counts.completed); // 3
console.log(batch.request_counts.failed);    // 0
console.log(batch.output_file_id);           // "file_xyz789"

batch = sdk.llm.batches.get(batch_id="batch_abc123")

print(batch.status)                  # "completed"
print(batch.request_counts.completed)  # 3
print(batch.request_counts.failed)     # 0
print(batch.output_file_id)           # "file_xyz789"

var batch = await sdk.Llm.Batches.GetAsync("batch_abc123");

Console.WriteLine(batch.BatchObject!.Status);                // "completed"
Console.WriteLine(batch.BatchObject!.RequestCounts);         // { Total: 3, Completed: 3, Failed: 0 }
Console.WriteLine(batch.BatchObject!.OutputFileId);          // "file_xyz789"

mka1 llm batches get --batch-id batch_abc123

curl https://apigw.mka1.com/api/v1/llm/batches/batch_abc123 \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

Here is a polling helper that waits for the batch to finish, up to a deadline:

async function waitForBatch(batchId: string, timeoutMs = 120_000) {
  const terminal = ['completed', 'failed', 'cancelled'];
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const batch = await sdk.llm.batches.get({ batchId });
    if (terminal.includes(batch.status)) return batch;
    await new Promise((r) => setTimeout(r, 2000));
  }

  throw new Error(`Batch ${batchId} did not complete within ${timeoutMs}ms`);
}

const completed = await waitForBatch(batch.id);

async function waitForBatch(batchId: string, timeoutMs = 120_000) {
  const terminal = ['completed', 'failed', 'cancelled'];
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const batch = await openai.batches.retrieve(batchId);
    if (terminal.includes(batch.status)) return batch;
    await new Promise((r) => setTimeout(r, 2000));
  }

  throw new Error(`Batch ${batchId} did not complete within ${timeoutMs}ms`);
}

const completed = await waitForBatch(batch.id);

def wait_for_batch(sdk, batch_id, timeout_ms=120_000):
    terminal = {"completed", "failed", "cancelled"}
    start = time.time() * 1000

    while (time.time() * 1000) - start < timeout_ms:
        batch = sdk.llm.batches.get(batch_id=batch_id)
        if batch.status in terminal:
            return batch
        time.sleep(2)

    raise TimeoutError(f"Batch {batch_id} did not complete within {timeout_ms}ms")

completed = wait_for_batch(sdk, batch.id)

async Task<BatchObject> WaitForBatch(SDK sdk, string batchId, int timeoutMs = 300_000)
{
    var terminal = new HashSet<BatchObjectStatus>
    {
        BatchObjectStatus.Completed,
        BatchObjectStatus.Failed,
        BatchObjectStatus.Cancelled,
    };
    var start = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

    while (DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - start < timeoutMs)
    {
        var batch = await sdk.Llm.Batches.GetAsync(batchId);
        if (terminal.Contains(batch.BatchObject!.Status))
            return batch.BatchObject;
        await Task.Delay(2000);
    }

    throw new TimeoutException($"Batch {batchId} did not complete within {timeoutMs}ms");
}

var completed = await WaitForBatch(sdk, batch.BatchObject!.Id);
Console.WriteLine(completed.Status); // BatchObjectStatus.Completed

# Poll a batch until it reaches a terminal status or 2 minutes pass, using --jq and a shell loop.
BATCH_ID=batch_abc123
DEADLINE=$((SECONDS + 120))
while (( SECONDS < DEADLINE )); do
  STATUS=$(mka1 llm batches get --batch-id "$BATCH_ID" --jq '.status' --output-format json | tr -d '"')
  echo "status: $STATUS"
  case "$STATUS" in
    completed|failed|cancelled) break ;;
  esac
  sleep 2
done

Step 5 — Download the results

Once the batch is completed, download the output file. It is a JSONL file where each line contains the custom_id you provided, the response, and any error.

const stream = await sdk.llm.files.content({ fileId: completed.outputFileId! });
const reader = stream.getReader();
const chunks: Uint8Array[] = [];
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  chunks.push(value);
}
const text = new TextDecoder().decode(Buffer.concat(chunks));

const results = text
  .split('\n')
  .filter((line) => line.trim())
  .map((line) => JSON.parse(line));

for (const result of results) {
  console.log(`${result.custom_id}: status=${result.response.status_code}`);
  console.log(`  body:`, result.response.body);
}

const content = await openai.files.content(completed.output_file_id!);
const text = await content.text();

const results = text
  .split('\n')
  .filter((line) => line.trim())
  .map((line) => JSON.parse(line));

for (const result of results) {
  console.log(`${result.custom_id}: status=${result.response.status_code}`);
  console.log(`  body:`, result.response.body);
}

content = sdk.llm.files.content(file_id=completed.output_file_id)
text = content.decode("utf-8")

results = [json.loads(line) for line in text.strip().split("\n") if line.strip()]

for result in results:
    print(f"{result['custom_id']}: status={result['response']['status_code']}")
    print(f"  body: {result['response']['body']}")

var content = await sdk.Llm.Files.ContentAsync(completed.OutputFileId!);

var bytes = content.TwoHundredTextPlainBytes
    ?? content.TwoHundredApplicationJsonlBytes
    ?? content.TwoHundredApplicationJsonBytes;
var text = Encoding.UTF8.GetString(bytes!);

Console.WriteLine(text); // JSONL with one line per request

# Download the JSONL output file
mka1 llm files content \
  --file-id file_xyz789 \
  --output-file ./batch_output.jsonl

# Inspect the results inline with jq
mka1 llm files content --file-id file_xyz789 \
  --jq '"\(.custom_id): status=\(.response.status_code)"'

curl https://apigw.mka1.com/api/v1/llm/files/file_xyz789/content \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

Each line in the output file has this structure:

{
  "id": "req_abc123",
  "custom_id": "request-1",
  "response": {
    "status_code": 200,
    "request_id": "req_abc123",
    "body": { "...": "same shape as the synchronous endpoint response" }
  },
  "error": null
}

If a request failed, response is null and error contains the details:

{
  "id": "req_def456",
  "custom_id": "request-2",
  "response": null,
  "error": {
    "code": "processing_error",
    "message": "The request could not be processed."
  }
}

If any requests failed, the batch also provides an error_file_id containing only the failed entries.

Cancel a batch

Cancel a batch that is still in progress. Requests that have already completed remain in the output.

const cancelled = await sdk.llm.batches.cancel({ batchId: 'batch_abc123' });
console.log(cancelled.status); // "cancelling"

const cancelled = await openai.batches.cancel('batch_abc123');
console.log(cancelled.status); // "cancelling"

cancelled = sdk.llm.batches.cancel(batch_id="batch_abc123")
print(cancelled.status)  # "cancelling"

var cancelled = await sdk.Llm.Batches.CancelAsync("batch_abc123");
Console.WriteLine(cancelled.BatchObject!.Status); // "cancelling"

mka1 llm batches cancel --batch-id batch_abc123

curl https://apigw.mka1.com/api/v1/llm/batches/batch_abc123/cancel \
  --request POST \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

The batch transitions to cancelling while in-flight requests finish, then to cancelled.

List batches

Retrieve all batches for the current account, newest first. Supports pagination.

const page = await sdk.llm.batches.list({ limit: 20 });

for (const batch of page.data) {
  console.log(`${batch.id}: ${batch.status} (${batch.requestCounts?.completed}/${batch.requestCounts?.total})`);
}

const page = await openai.batches.list({ limit: 20 });

for (const batch of page.data) {
  console.log(`${batch.id}: ${batch.status} (${batch.request_counts?.completed}/${batch.request_counts?.total})`);
}

page = sdk.llm.batches.list(limit=20)

for batch in page.data:
    print(f"{batch.id}: {batch.status} ({batch.request_counts.completed}/{batch.request_counts.total})")

var page = await sdk.Llm.Batches.ListAsync(limit: 20);

foreach (var batch in page.ListBatchesResponseValue!.Data!)
{
    Console.WriteLine($"{batch.Id}: {batch.Status} ({batch.RequestCounts?.Completed}/{batch.RequestCounts?.Total})");
}

mka1 llm batches list --limit 20

curl 'https://apigw.mka1.com/api/v1/llm/batches?limit=20' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>'

Use the after parameter with a batch ID to page through results.

Example: batch chat completions

The same flow works for chat completions. Change the url in each JSONL line and the endpoint when creating the batch.

{"custom_id": "chat-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "auto", "messages": [{"role": "user", "content": "What is the capital of France?"}], "max_tokens": 100}}
{"custom_id": "chat-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "auto", "messages": [{"role": "user", "content": "Explain embeddings in one paragraph."}], "max_tokens": 100}}

const file = await sdk.llm.files.upload({
  requestBody: {
    file: new File([jsonlContent], 'chat_batch.jsonl', { type: 'application/x-ndjson' }),
    purpose: 'batch',
  },
});

const batch = await sdk.llm.batches.create({
  createBatchRequest: {
    inputFileId: file.id,
    endpoint: '/v1/chat/completions',
    completionWindow: '24h',
    maxConcurrency: 4,
  },
});

const completed = await waitForBatch(batch.id);
const stream = await sdk.llm.files.content({ fileId: completed.outputFileId! });
// ... read stream as shown in Step 5

const file = await openai.files.create({
  file: new File([jsonlContent], 'chat_batch.jsonl', { type: 'application/x-ndjson' }),
  purpose: 'batch',
});

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: '/v1/chat/completions',
  completion_window: '24h',
  max_concurrency: 4,
});

const completed = await waitForBatch(batch.id);
const content = await openai.files.content(completed.output_file_id!);
const results = (await content.text()).split('\n').filter(Boolean).map((line) => JSON.parse(line));

for (const r of results) {
  console.log(`${r.custom_id}: ${r.response.body.choices[0].message.content}`);
}

file = sdk.llm.files.upload(
    file={"file_name": "chat_batch.jsonl", "content": open("chat_batch.jsonl", "rb")},
    purpose="batch",
)

batch = sdk.llm.batches.create(
    input_file_id=file.id,
    endpoint="/v1/chat/completions",
    max_concurrency=4,
)

completed = wait_for_batch(sdk, batch.id)
# Download and parse results as shown in Step 5

var file = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
{
    File = new UploadFileFile()
    {
        FileName = "chat_batch.jsonl",
        Content = Encoding.UTF8.GetBytes(jsonlContent),
    },
    Purpose = UploadFilePurpose.Batch,
});

var batch = await sdk.Llm.Batches.CreateAsync(new CreateBatchRequest()
{
    InputFileId = file.File!.Id,
    Endpoint = BatchEndpoint.RootV1ChatCompletions,
    MaxConcurrency = 4,
});

var completed = await WaitForBatch(sdk, batch.BatchObject!.Id);
// Download and parse results as shown in Step 5

# Upload the chat completions JSONL input
FILE_ID=$(mka1 llm files upload \
  --file ./chat_batch.jsonl \
  --purpose batch \
  --jq '.id' --output-format json | tr -d '"')

# Create the batch against the chat completions endpoint
mka1 llm batches create --body "{
  \"input_file_id\": \"$FILE_ID\",
  \"endpoint\": \"/v1/chat/completions\",
  \"completion_window\": \"24h\",
  \"max_concurrency\": 4
}"

# Poll, then download the results — see Steps 4 and 5

Example: batch embeddings

The same flow works for embeddings. Change the url in each JSONL line and the endpoint when creating the batch.

{"custom_id": "embed-1", "method": "POST", "url": "/v1/embeddings", "body": {"model": "auto", "input": "The quick brown fox"}}
{"custom_id": "embed-2", "method": "POST", "url": "/v1/embeddings", "body": {"model": "auto", "input": "jumps over the lazy dog"}}

const file = await sdk.llm.files.upload({
  requestBody: {
    file: new File([jsonlContent], 'embed_batch.jsonl', { type: 'application/x-ndjson' }),
    purpose: 'batch',
  },
});

const batch = await sdk.llm.batches.create({
  createBatchRequest: {
    inputFileId: file.id,
    endpoint: '/v1/embeddings',
    completionWindow: '24h',
    maxConcurrency: 4,
  },
});

const completed = await waitForBatch(batch.id);
const stream = await sdk.llm.files.content({ fileId: completed.outputFileId! });
// ... read stream as shown in Step 5

const file = await openai.files.create({
  file: new File([jsonlContent], 'embed_batch.jsonl', { type: 'application/x-ndjson' }),
  purpose: 'batch',
});

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: '/v1/embeddings',
  completion_window: '24h',
  max_concurrency: 4,
});

const completed = await waitForBatch(batch.id);
const content = await openai.files.content(completed.output_file_id!);
const results = (await content.text()).split('\n').filter(Boolean).map((line) => JSON.parse(line));

for (const r of results) {
  console.log(`${r.custom_id}: ${r.response.body.data[0].embedding.length} dimensions`);
}

file = sdk.llm.files.upload(
    file={"file_name": "embed_batch.jsonl", "content": open("embed_batch.jsonl", "rb")},
    purpose="batch",
)

batch = sdk.llm.batches.create(
    input_file_id=file.id,
    endpoint="/v1/embeddings",
    max_concurrency=4,
)

completed = wait_for_batch(sdk, batch.id)
# Download and parse results as shown in Step 5

var file = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
{
    File = new UploadFileFile()
    {
        FileName = "embed_batch.jsonl",
        Content = Encoding.UTF8.GetBytes(jsonlContent),
    },
    Purpose = UploadFilePurpose.Batch,
});

var batch = await sdk.Llm.Batches.CreateAsync(new CreateBatchRequest()
{
    InputFileId = file.File!.Id,
    Endpoint = BatchEndpoint.RootV1Embeddings,
    MaxConcurrency = 4,
});

var completed = await WaitForBatch(sdk, batch.BatchObject!.Id);
// Download and parse results as shown in Step 5

# Upload the embeddings JSONL input
FILE_ID=$(mka1 llm files upload \
  --file ./embed_batch.jsonl \
  --purpose batch \
  --jq '.id' --output-format json | tr -d '"')

# Create the batch against the embeddings endpoint
mka1 llm batches create --body "{
  \"input_file_id\": \"$FILE_ID\",
  \"endpoint\": \"/v1/embeddings\",
  \"completion_window\": \"24h\",
  \"max_concurrency\": 4
}"

# Poll, then download the results — see Steps 4 and 5

Validation errors

If the input file has formatting issues, the batch moves to failed immediately. Common causes:

Invalid JSON — a line is not valid JSON.
Missing fields — a line is missing custom_id, method, url, or body.
Wrong method — method must be "POST".
URL mismatch — the url in a line does not match the endpoint declared when creating the batch.
Duplicate custom_id — each custom_id must be unique within the file.

Check batch.errors.data for the specific error messages and line numbers.

const batch = await sdk.llm.batches.get({ batchId: 'batch_abc123' });

if (batch.status === 'failed' && batch.errors) {
  for (const err of batch.errors.data ?? []) {
    console.log(`Line ${err.line}: [${err.code}] ${err.message}`);
  }
}

const batch = await openai.batches.retrieve('batch_abc123');

if (batch.status === 'failed' && batch.errors) {
  for (const err of batch.errors.data ?? []) {
    console.log(`Line ${err.line}: [${err.code}] ${err.message}`);
  }
}

batch = sdk.llm.batches.get(batch_id="batch_abc123")

if batch.status == "failed" and batch.errors:
    for err in batch.errors.data or []:
        print(f"Line {err.line}: [{err.code}] {err.message}")

var batch = await sdk.Llm.Batches.GetAsync("batch_abc123");

if (batch.BatchObject!.Status == BatchObjectStatus.Failed && batch.BatchObject.Errors != null)
{
    foreach (var err in batch.BatchObject.Errors.Data ?? new List<BatchObjectErrorsData>())
    {
        Console.WriteLine($"Line {err.Line}: [{err.Code}] {err.Message}");
    }
}

mka1 llm batches get --batch-id batch_abc123 \
  --jq '.errors.data[] | "Line \(.line): [\(.code)] \(.message)"'

Get started

SDKs and CLI

Responses

Standalone APIs

Agents

Evals

Compute

Authentication

Production

Batch processing

How batches run

Supported endpoints

Lifecycle

Step 1 — Prepare the input file

Step 2 — Upload the input file

Step 3 — Create the batch

Step 4 — Check batch status

Step 5 — Download the results

Cancel a batch

List batches

Example: batch chat completions

Example: batch embeddings

Validation errors

See also

​How batches run

​Supported endpoints

​Lifecycle

​Step 1 — Prepare the input file

​Step 2 — Upload the input file

​Step 3 — Create the batch

​Step 4 — Check batch status

​Step 5 — Download the results

​Cancel a batch

​List batches

​Example: batch chat completions

​Example: batch embeddings

​Validation errors

​See also

How batches run

Supported endpoints

Lifecycle

Step 1 — Prepare the input file

Step 2 — Upload the input file

Step 3 — Create the batch

Step 4 — Check batch status

Step 5 — Download the results

Cancel a batch

List batches

Example: batch chat completions

Example: batch embeddings

Validation errors

See also