GPT 5.6 Luna Pro:Batch API: What It Is, Pricing & How to Access It (2026)

A 900,000-token document set sent to openai/gpt-5.6-luna-pro:batch costs $0.09 to ingest. If the model generates 25,000 tokens, the output adds $0.015, bringing the model charge to about $0.105 before platform fees, retries, or ancillary services.

That combination—a 1,050,000-token context window and vendor pricing of $0.10 per million prompt tokens—is the reason GPT 5.6 Luna Pro:Batch deserves attention. It makes workloads such as repository-wide analysis, document classification, extraction, and offline synthesis economically possible without aggressive chunking.

The caveat is equally important: public details are still emerging. The route is listed as openai/gpt-5.6-luna-pro:batch, but a comprehensive model card, architecture description, benchmark set, and detailed training disclosure are not yet established in the information available here. Treat the route’s published context and pricing as concrete; treat broad intelligence or reliability claims as hypotheses to test.

What GPT 5.6 Luna Pro:Batch is

GPT 5.6 Luna Pro:Batch is a large-context model route exposed through OpenRouter with this identifier:

openai/gpt-5.6-luna-pro:batch

The known operational details are:

The openai/ namespace attributes the route to OpenAI within OpenRouter’s model catalog. However, the namespace alone does not answer every provenance question. Until fuller first-party documentation is available, I would not assume that “Luna Pro” maps neatly to a separately documented OpenAI checkpoint, nor infer its architecture from the GPT 5.6 name.

The :batch suffix also matters. It indicates a route intended for batch-style processing, where throughput and cost typically matter more than interactive latency. It should not be read as proof of a further undocumented discount. The prices supplied for this route—$0.10/M input and $0.60/M output—are the numbers to use in a cost model.

Where it fits among current models

The current model market is no longer a single quality ladder. It is a matrix of latency, reasoning ability, context capacity, modality, tool use, availability, and price.

GPT 5.6 Luna Pro:Batch’s clearest position is low-cost, very-long-context, asynchronous processing. That is different from choosing a premium interactive model for an IDE agent or a small model for a live autocomplete path.

This table deliberately avoids declaring an overall winner. No confirmed benchmark data supplied for Luna Pro:Batch justifies that conclusion. In practice, I would test at least 100 representative jobs and score schema validity, factual support, retrieval accuracy, completion length, latency, and retry rate.

A cheap token is not cheap if the model produces three times as many output tokens or requires repeated repair calls.

The standout strengths—and their limits

A 1.05-million-token context envelope

A 1,050,000-token window can hold unusually large inputs: multiple books, a sizeable source repository, extensive support histories, or thousands of normalized business records.

What actually happens when teams receive a million-token window, though, is that they initially treat it like perfect searchable storage. It is not. Context capacity tells us what the API can accept, not how reliably the model recalls one sentence buried at token 723,000.

For long-context jobs:

• Put the task and output contract near the beginning and repeat critical constraints near the end.
• Add stable document IDs and explicit delimiters.
• Request evidence using IDs or line ranges.
• Remove irrelevant generated files, duplicate documents, and binary-derived text.
• Test retrieval at early, middle, and late positions.
• Reserve context space for the completion and any provider-added tokens.

A common gotcha is sending exactly 1,050,000 input tokens and expecting room for output. “Context length” generally describes the shared input-output envelope unless the provider documents otherwise. Stay below the ceiling and verify the route’s current limits.

Extremely low input cost

At the stated rate, input-heavy jobs are inexpensive:

def model_cost(prompt_tokens: int, completion_tokens: int) -> float:
    return (
        prompt_tokens * 0.0000001
        + completion_tokens * 0.0000006
    )

print(model_cost(900_000, 25_000))  # 0.105

Here are several model-charge examples:

The final row is calculated as:

Input:  30,000,000 × $0.0000001 = $3.00
Output:    500,000 × $0.0000006 = $0.30
Total:                                $3.30

These figures are model-token estimates, not guaranteed invoices. Routing platforms may add fees, tokenization can differ from local estimates, failed requests may have billable usage, and taxes or currency conversion may apply.

Batch-friendly throughput

Batch models fit workloads that do not need a response while a user waits:

• Nightly repository summaries
• Large-scale classification and tagging
• Contract clause extraction
• Dataset enrichment
• Support-ticket clustering
• Evaluation-set grading
• Migration analysis across many files

The trade-off is latency. Batch capacity may queue, and completion time can vary. Keep interactive and batch service-level objectives separate rather than placing both behind one route.

Calling the model through an OpenAI-compatible API

OpenRouter exposes an OpenAI-style chat completions interface. Store the key in an environment variable rather than embedding it in code.

export OPENROUTER_API_KEY="replace-with-your-key"

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-luna-pro:batch",
    "messages": [
      {
        "role": "system",
        "content": "Return strict JSON. Cite each finding by document_id."
      },
      {
        "role": "user",
        "content": "Analyze the supplied records and identify conflicting requirements."
      }
    ],
    "temperature": 0.1,
    "max_tokens": 3000
  }'

Using the OpenAI Python SDK:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OPENROUTER_API_KEY"],
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-5.6-luna-pro:batch",
    messages=[
        {
            "role": "system",
            "content": "Extract risks as JSON with source_document_id.",
        },
        {
            "role": "user",
            "content": "DOCUMENT_ID: policy-17\n\n" + open(
                "policy.txt", encoding="utf-8"
            ).read(),
        },
    ],
    temperature=0,
    max_tokens=4000,
)

print(response.choices[0].message.content)
print(response.usage)

Do not assume that every OpenAI-compatible field is supported identically. Structured outputs, tool calls, seed behavior, log probabilities, multimodal parts, and reasoning controls can differ by model and route.

Using an Anthropic-compatible client

“Anthropic-compatible” should mean that your gateway explicitly implements Anthropic’s Messages API—not merely that it accepts an API key for multiple vendors. OpenRouter’s documented common path is OpenAI-compatible, so verify Anthropic endpoint support before changing only the base URL.

For a gateway that implements the Anthropic contract, the pattern is:

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["MULTI_MODEL_API_KEY"],
    base_url=os.environ["ANTHROPIC_COMPATIBLE_BASE_URL"],
)

message = client.messages.create(
    model="openai/gpt-5.6-luna-pro:batch",
    max_tokens=2000,
    system="Produce JSON and include evidence IDs.",
    messages=[
        {
            "role": "user",
            "content": "Compare these normalized incident reports...",
        }
    ],
)

print(message.content[0].text)

In practice, the safest abstraction is an internal request schema with adapters for OpenAI and Anthropic formats. Normalize usage accounting and errors at that boundary. This prevents application code from depending on one provider’s message blocks, tool-call representation, or retry semantics.

AI Prime Tech can also be considered when consolidating cheaper Claude, GPT, and Gemini API access, with advertised savings of up to 80%. As with any multi-model gateway, compare the actual model IDs, rate limits, data-handling terms, compatibility surface, and final invoice—not only the headline discount.

Cost controls that matter in production

Start with these controls:

1. Cap output aggressively. Output costs six times as much per token as input on this route.
2. Pre-count tokens. Use the correct tokenizer when available, while allowing a safety margin.
3. Deduplicate context. Repeated boilerplate can dominate million-token jobs.
4. Split retryable units. One enormous request is expensive to repeat after a malformed result.
5. Require compact schemas. Short keys and bounded arrays reduce completion usage.
6. Record actual usage. Log prompt tokens, completion tokens, route, status, and estimated cost.
7. Set a budget guardrail. Reject or queue requests that exceed a per-job token threshold.
8. Evaluate effective recall. More context is useful only when the answer remains grounded.

For extraction, I usually prefer batches of independently retryable documents over filling the entire context window. For cross-document synthesis, larger bundles make sense, but include a manifest and demand evidence references.

Practical takeaways

• GPT 5.6 Luna Pro:Batch is most compelling as a low-cost, million-token-class batch route, not automatically as a replacement for every interactive model.
• Its confirmed pricing is $0.10 per million prompt tokens and $0.60 per million completion tokens.
• Use openai/gpt-5.6-luna-pro:batch through an OpenAI-compatible endpoint; use Anthropic SDKs only with a gateway that explicitly supports the Anthropic Messages API.
• Treat the 1,050,000-token limit as an envelope, not evidence of perfect recall.
• Do not infer undocumented capabilities, benchmark leadership, or extra discounts from the model name and :batch suffix.
• Run a representative evaluation against GPT-5.5, Claude-family models, Gemini 3, Fable 5, MiniMax, Qwen, and DeepSeek before committing a production workload.
• Optimize outputs first: at the published rates, completion tokens are the dominant marginal cost.