OpenAI Batch API vs Realtime Cost: What Actually Wins in Production? (2026)

Last verified: July 24, 2026

Short path: Compare GPT API options, review lower-cost OpenAI-compatible access, and check AI API pricing. For the concrete model used below, see gpt-5.6-terra.

Your nightly job probably can move to OpenAI Batch API. That does not automatically mean it is your lowest-cost option.

The OpenAI Batch API cuts eligible direct OpenAI token pricing by 50% in exchange for asynchronous processing. But for gpt-5.6-terra, LumeAPI’s realtime catalog rate is already 70% below the listed official realtime rate—and 40% below the calculated direct Batch rate. Batch is still useful when a 24-hour completion window is acceptable and you need OpenAI’s native batch workflow. It is not a magic “halve every GPT bill” button.

Quick Answer

In short

Use OpenAI Batch when you are staying direct with OpenAI, your work can wait, and the 50% official discount is worth the batch pipeline you must operate. Do not move every workload there just because it runs overnight.

For the gpt-5.6-terra rates listed here, LumeAPI realtime costs less per token than the discounted direct Batch estimate. The better production decision is usually to separate your queue by deadline: native Batch for work that genuinely needs its workflow, lower-cost realtime access for work that cannot wait—or cannot tolerate batch reconciliation complexity.

What most guides get wrong

The myth: “Anything asynchronous should go to Batch because it is half price.”

Half price compared with what matters. OpenAI’s Batch API discount is measured against OpenAI’s standard API rates, not against every OpenAI-compatible route you could use. If your existing baseline is direct OpenAI realtime, moving a nightly enrichment job to Batch can be a clean 50% token-price reduction. If your baseline is LumeAPI’s catalog pricing, the same arithmetic can point the other way.

The second mistake is treating a batch run as one cheap request. It is a small pipeline: create JSONL input, upload it, create the batch, poll status, retrieve output, map each custom ID back to application records, retry only failed rows, and prevent duplicate writes. The token discount is real. So is the engineering surface area.

A $40 nightly job is worth optimizing. A $2 nightly job that now needs a custom reconciliation worker may not be.

A realistic production scenario

Nina’s team runs a TypeScript service that classifies support conversations after business hours. Every night, a PostgreSQL query pulls roughly 180,000 closed tickets, a worker formats each one into a structured extraction prompt, and the results are written into a warehouse for the support analytics team.

The first version fired realtime calls in a loop. It worked until a backlog landed after a product outage: 2.7 million input tokens and 900,000 output tokens in one run. Somebody saw “Batch is 50% off,” moved the queue, and assumed the work was done.

By Thursday, the bill was lower—but the dashboard had gaps. A few malformed records failed, the batch output arrived after the warehouse job had already marked the run complete, and retries reprocessed rows that had succeeded. The fix was not “use a cheaper model.” It was stable custom_id values, a pending/completed/failed state machine, idempotent warehouse writes, and a deadline rule: tickets needed for the morning report could use Batch; tickets needed by an on-call manager stayed realtime.

That is the actual comparison: token price, delivery deadline, and failure handling.

Expert take

Batch discounts reward work that has no interactive deadline. They do not reduce prompt bloat, runaway output, duplicated retries, or a worker that sends the same 12,000-token transcript to three separate classification steps.

That distinction matters because output tokens are often the expensive part. For gpt-5.6-terra, the listed official realtime price is $2.50 per 1M input tokens and $15.00 per 1M output tokens. Even after the 50% Batch discount, output is still $7.50 per 1M tokens. If your extraction prompt asks for verbose explanations, you can erase much of the expected savings before deciding between Batch and realtime.

The practical rule is blunt:

• Use Batch for large, independent records that can wait and can be reconciled safely.
• Use realtime for user-facing requests, on-call tooling, workflows with hard deadlines, and jobs where partial completion causes trouble.
• Reduce output caps and remove repeated context before changing transport.
• Compare Batch against your actual alternative, not just OpenAI’s list price.

There are also cases where you should not follow the “LumeAPI realtime is cheaper” conclusion. Use the official OpenAI Batch API when your application requires its native batch lifecycle, your procurement or compliance rules require direct-provider processing, or you have already built reliable file-based reconciliation around OpenAI’s workflow. LumeAPI is an independent third-party gateway, not OpenAI, Anthropic, or Google. Its OpenAI-compatible Chat Completions endpoint should not be assumed to provide parity with every provider-native feature, including Batch-specific workflows.

For current Batch mechanics and eligibility constraints, verify against the official OpenAI Batch API guide. For reference pricing, use OpenAI’s API pricing page.

The price math: direct realtime, OpenAI Batch, and LumeAPI

The following comparison uses the live catalog rates supplied for this article, updated July 22, 2026.

OpenAI documents a 50% discount for Batch API input and output token pricing relative to standard pricing. The “Official Batch” column below is therefore calculated as 50% of the listed official realtime rate. It is an estimate for cost planning; confirm the current model’s Batch eligibility and price on OpenAI’s official pricing page before deploying.

Monthly example: a nightly extraction queue

Assume a monthly workload of:

• 30 million input tokens
• 10 million output tokens
• gpt-5.6-terra
• No cached-token, storage, file, tool, or network costs included
• All requests qualify for the OpenAI Batch API’s stated 50% discount

The monthly token calculation is:

input cost = input tokens / 1,000,000 × input price
output cost = output tokens / 1,000,000 × output price
monthly cost = input cost + output cost

For this scenario:

• OpenAI Batch saves $112.50 per month versus official realtime.
• LumeAPI realtime saves $157.50 per month versus official realtime.
• LumeAPI realtime is $45.00 per month lower than the calculated official Batch cost.

That is why “Batch gives an OpenAI Batch API 50 percent discount” is true but incomplete. Batch is a discount from direct realtime. It is not necessarily the cheapest way to run a deferrable GPT workload.

Where batch vs chat completions pricing changes the decision

The phrase “batch vs chat completions pricing” makes it sound as if you are only picking a unit price. You are really choosing a service contract.

The key boundary is not “does this job run overnight?” It is: can every individual item wait, be retried independently, and be reconciled after asynchronous completion?

If one item failing prevents a financial close, an incident report, or a customer communication from shipping, Batch may create more operational risk than it removes.

When to use OpenAI Batch API

Use OpenAI Batch API when these conditions are all true:

1. The request is not on an interactive path. Nobody is waiting on an HTTP response, streaming result, or tool decision.
2. Records are independent. A failed item can be retried without rerunning the entire dataset.
3. You have a stable identifier for every row. Your output handler can map results to source records and avoid duplicate writes.
4. Your deadline has slack. “Runs at midnight” is not enough. Define the latest acceptable completion time and an escalation path.
5. The direct-provider 50% discount beats your real alternative. Compare output-heavy workloads carefully.
6. Your team can operate the lifecycle. File creation, status polling, failed-row handling, data retention, and alerting are part of the implementation.

Do not use Batch merely because a cron job exists. A cron job may still power customer-facing search indexes, fraud review queues, shipping labels, or executive reports with real deadlines.

For a deeper cost framework across providers and asynchronous workloads, read how Batch API can cut OpenAI, Claude, and Gemini API costs.

The cost leak Batch does not fix: repeated context

Batch reduces the rate charged for tokens. It does not reduce the number of tokens you submit.

A common anti-pattern looks like this:

1. Send a full conversation transcript to classify intent.
2. Send the same transcript again to extract account fields.
3. Send it a third time to draft a resolution summary.
4. Batch all three jobs and celebrate the 50% discount.

You did get the discount. You also paid for three copies of the same context.

Before choosing a route, inspect a day of production logs and answer:

• How many input tokens are repeated across steps?
• Which prompts need verbose prose instead of structured fields?
• Are retries reusing the same idempotency key or creating duplicate work?
• Does each model call need the full transcript, or only the last few messages plus a compact state summary?
• Are you generating explanations that no downstream system reads?

A 30% reduction in unnecessary output tokens stacks with a Batch discount. So does using a smaller model where quality holds. The reverse is also true: moving an inflated prompt to Batch makes the inflated prompt cheaper, not efficient.

Prompt reuse can matter more than execution mode for retrieval-heavy systems. See how prompt caching affects API costs before assuming the scheduler is your largest lever.

A migration runbook: split the queue before you move it

Do not flip an entire workload from direct OpenAI realtime to Batch in one deployment. Classify it first.

1. Build a deadline inventory

For each job, record:

“Can wait” must be a written deadline, not a feeling.

2. Measure input and output separately

Do not model all tokens at one blended rate. For gpt-5.6-terra, output costs six times as much as input in the supplied official realtime catalog: $15.00 versus $2.50 per 1M tokens.

If your job is output-heavy, cutting a response from 1,000 tokens to 250 tokens can outrun smaller routing changes. Require structured output only where it is consumed, cap length where possible, and avoid asking for a rationale that gets discarded.

3. Make every result idempotent

Use an application-level job ID, source version, and deterministic destination key. If a record returns twice, your database write should update the same row rather than create a second report or trigger a second downstream workflow.

This is the part most “move it to Batch” migration guides skip. The API request is easy. Recovery after a partially completed job is where the weekend goes.

4. Pilot one bounded dataset

Start with a dataset you can validate manually: perhaps 1,000 records with known expected categories. Track:

• Submitted record count
• Completed record count
• Failed record count
• Duplicate result count
• Input and output tokens
• Completion deadline
• Cost per useful record

Do not declare success because the batch was accepted. Declare success when the reconciled output is complete, correctly mapped, and cheaper after retries.

5. Keep a realtime escape hatch

If a batch job misses its operational deadline, you need a policy. That might mean rerunning only incomplete records synchronously, delaying a report, or falling back to a lower-cost realtime route. Decide that policy before the first failure, not during an incident.

Realtime cost control with LumeAPI Chat Completions

If you decide a queue needs realtime behavior—or the LumeAPI rate is lower than calculated Batch pricing—you can use the OpenAI-compatible Chat Completions endpoint.

This example sends a compact extraction request to gpt-5.6-terra. It intentionally sets a constrained output request rather than asking the model for an essay.

curl https://api.lumeapi.site/v1/chat/completions \
  -H "Authorization: Bearer $LUMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "messages": [
      {
        "role": "system",
        "content": "Extract only the requested fields. Keep values concise."
      },
      {
        "role": "user",
        "content": "Classify this closed support ticket and return: category, urgency, and one-sentence summary.\n\nTicket: Customer cannot export invoices from the billing page after changing account ownership."
      }
    ]
  }'

The base URL changes, but your application still needs the same production discipline:

• Record request and response identifiers in your own job table.
• Put a cap on queue concurrency based on your observed error handling capacity.
• Retry only failures you can identify safely.
• Store the source record version with the result.
• Alert on a growing backlog before it becomes tomorrow morning’s emergency.

LumeAPI provides transparent per-token catalog rates through a USD wallet, but it is not a substitute for provider-native Batch APIs or every native OpenAI feature. Treat it as a lower-cost OpenAI-compatible realtime route, not as automatic failover or feature parity.

For a broader migration path from direct OpenAI pricing, see what to do when your OpenAI API bill is too expensive.

A simple decision rule for finance and engineering

Use this formula before changing your pipeline:

Savings from Batch =
direct realtime token cost − direct Batch token cost

Savings from LumeAPI realtime =
direct realtime token cost − LumeAPI realtime token cost

Operational value of Batch =
Batch savings − engineering and delay cost

For gpt-5.6-terra, the direct price comparison is straightforward:

Official realtime: $2.50 input / $15.00 output per 1M tokens
Official Batch:    $1.25 input / $7.50 output per 1M tokens
LumeAPI realtime:  $0.75 input / $4.50 output per 1M tokens

If direct Batch saves $1,000 a month but adds a workflow your team cannot safely monitor, it may not be a win. If you already operate robust asynchronous data pipelines and your legal team requires direct OpenAI, Batch is probably the right move. If you need lower unit cost with immediate responses and standard Chat Completions behavior, LumeAPI realtime is the cleaner answer on the catalog rates shown here.

The point is not to be loyal to a transport. The point is to stop paying premium realtime prices for work that can wait—and stop introducing Batch complexity where a lower-cost realtime route is enough.

FAQ

Is OpenAI Batch API vs realtime cost always a 50% saving?

No. It is a 50% discount against eligible direct OpenAI standard pricing, not a guarantee that Batch is the cheapest route available. Compare the model’s direct Batch price with your actual realtime alternative and include the operational cost of batch handling.

Does the OpenAI Batch API 50 percent discount apply to input and output tokens?

OpenAI documents a 50% Batch API discount for eligible input and output token pricing. Because model availability and pricing can change, verify the specific model on the official OpenAI pricing page and Batch documentation before relying on an estimate.

When should I use OpenAI Batch API instead of realtime Chat Completions?

Use OpenAI Batch API for independent, deferrable jobs with reliable reconciliation and a clear completion buffer. Use realtime Chat Completions when a user, operational workflow, or downstream system needs the result immediately.

Is batch vs chat completions pricing the only factor in the decision?

No. Price is only one factor. Batch also changes completion timing, error recovery, result retrieval, observability, and how you prevent duplicate processing after partial failures.

Can I submit OpenAI Batch jobs through LumeAPI?

Do not assume so. The LumeAPI facts provided for this article cover an OpenAI-compatible Chat Completions endpoint at https://api.lumeapi.site/v1, not provider-native Batch API parity. Use OpenAI’s official documentation for direct Batch workflows.

Why is my Batch bill still high after the discount?

The Batch discount lowers token rates, but it does not remove repeated prompt context, verbose output, duplicate retries, or unnecessary model calls. Review token logs by input, output, task type, and retry reason before assuming the scheduling mode is the problem.

Next steps

1. Pull one week of production usage and calculate input and output tokens separately for each scheduled job.
2. Put every job into one of three buckets: realtime required, Batch candidate, or needs prompt/output reduction first.
3. For workloads that need immediate results, compare your current direct rate with LumeAPI’s lower-cost GPT API option before building a batch pipeline you may not need.