LLM Max Output Tokens: API Limits and Context Budgets

A million-token context window tells you very little about how long an answer an LLM can produce. GPT-5.6 Luna lists a 1,050,000-token context window but a 128,000-token output maximum. MiniMax M3's native API publishes a 524,288-token generation cap. Those are different constraints, even before reasoning consumes part of a response budget.^[1]^[2]

The useful comparison is the task you can fit: input, generated work, and the interface delivering it. This guide compares LLM max output tokens for long reports, structured extraction, and code generation. It separates native provider specifications from reAPI's published interface, and synchronous requests from batch processing. Specifications were checked on September 8, 2026; a documented ceiling is not a promise that a model will produce that many useful tokens.

TL;DR

An output cap is separate from the context window. Luna allows 128,000 output tokens within its 1,050,000-token window; extra input capacity does not increase the output maximum.^[1]
A recommended value is not a default. MiniMax recommends 131,072 tokens for M3 and permits up to 524,288. Its current API page does not label 131,072 as the value used when the field is omitted.^[2]
The largest accepted parameter may not fit your input. Kimi K3 permits max_completion_tokens up to 1,048,576, but rejects a request when input plus that cap exceeds its context window.^[3]
DeepSeek's window is shared. V4 Flash and Pro list a 1M context and 384K maximum output; the API constrains the combined input and generated tokens.^[4]^[5]

LLM max output tokens by model and API

The table describes the providers' own APIs. “Not stated” means the retrieved specification did not give a numeric default. It does not mean unlimited output.

Model and API	Context window	Maximum generation budget	Default or recommendation	Output control
Kimi K3, native Chat Completions	1M, as the vendor labels it	Parameter range reaches 1,048,576; input plus cap must fit	Default 131,072	`max_completion_tokens`
DeepSeek V4 Flash / Pro, native Chat Completions	1M	384K; also bounded by available context	Numeric default not stated in the current pages	`max_tokens`
MiniMax M3, native OpenAI-compatible API	1M	524,288	Recommended 131,072; numeric default not stated	`max_completion_tokens`
GPT-5.6 Luna / GPT-6 Astra, native API	1,050,000	128,000	Numeric output default not stated on the model pages	Chat Completions: `max_completion_tokens`; Responses: `max_output_tokens`
Claude Opus 5 / Opus 4.8, synchronous Messages	1M	128K	Specify a request budget; sample values are not defaults	`max_tokens`
Claude Opus 5 / Opus 4.8, Message Batches with extended-output beta	1M	300,000	Requires the specific batch feature and beta header	`max_tokens`

Sources: Kimi's parameter and model pages; DeepSeek's pricing and API reference; MiniMax's API reference; OpenAI's Luna and Astra model pages; Anthropic's context and batch documentation.^[3]^[6]^[4]^[5]^[2]^[1]^[7]^[8]^[9]

Keep the units shown by the source. DeepSeek publishes 384K without an exact integer on these pages. MiniMax explicitly pairs 512K with 524,288. Converting every vendor's “K” by the same multiplier would add precision the sources do not support.

The Claude batch row is a separate capability. It requires output-300k-2026-03-24 on the Message Batches API, not the synchronous Messages API. Anthropic currently lists support on the Claude API and Claude Platform on AWS, with other hosting platforms excluded. A batch-capable native model does not establish that another gateway exposes this feature.^[9]

Reserve room for work the reader will never see

OpenAI's Chat Completions reference defines max_completion_tokens as a cap covering visible output and reasoning tokens. The Responses guide also includes non-visible formatting tokens in its generated-token budget. Claude likewise counts thinking toward max_tokens.^[10]^[11]^[8]

A planning calculation can therefore look like this:

Request budget:             30,000 generated tokens
Planning allowance for reasoning: 10,000 tokens
Room left for visible output:    20,000 tokens

These are illustrative allocations, not measurements or a promise about a model's reasoning length. If a response uses more reasoning than planned, less of the same allowance remains for its answer. Increasing effort can change the work performed without increasing the cap you sent.

For a long-form task, write down two requirements: the input that must remain available and the generation allowance the task needs. Count system instructions, retained messages, tool definitions, and tool results where the endpoint includes them. Then check both the output ceiling and the context constraint. A request can pass one and fail the other.^[8]

This matters when choosing models. A required generation budget of 150,000 tokens exceeds Luna's and Astra's 128,000 maximum, regardless of unused context. Claude's batch extension can accommodate a budget of that size under its documented conditions. That still says nothing about whether the resulting document will be complete, correct, or worth its cost.^[1]^[7]^[9]

Kimi's always-on reasoning is another reason to avoid advertising its largest parameter value as a million-token final answer. Its API imposes the input-plus-cap check before generation. MiniMax's page describes a generation-length limit, without promising that the entire allowance becomes useful answer text. Set an explicit cap and inspect what the response actually contains.^[3]^[12]^[2]

Match the parameter to the endpoint

OpenAI-compatible does not make every parameter interchangeable. OpenAI uses max_completion_tokens for Chat Completions and max_output_tokens for Responses. DeepSeek's native Chat Completions API uses max_tokens. MiniMax's current native OpenAI-compatible reference marks max_tokens deprecated in favor of max_completion_tokens.^[10]^[11]^[5]^[2]

Reasoning controls differ too. Kimi K3 accepts low, high, and max, defaulting to max. DeepSeek accepts those three values and defaults to high; its compatibility aliases medium and xhigh map to high. Luna supports none through several reasoning levels and defaults to medium. Astra does not support none; its current model page does not state a default effort.^[12]^[13]^[1]^[7]

Claude controls effort through output_config.effort. For Opus 5 and 4.8, the higher level is spelled xhigh, not extra. The documented default is high. Opus 5 enables adaptive thinking by default and only allows thinking to be disabled at high effort or below. Opus 4.8 starts with thinking disabled until it is enabled.^[14]^[15]

For reAPI, start with the current model catalog and the documentation linked from the selected model. The Luna model page states its context and output limits, while the Kimi API reference identifies the request field. Treat a native-provider default, an example's explicit value, and a gateway's actual behavior as separate facts. Specifying your intended cap removes one avoidable ambiguity.

Read the failure before changing models

The APIs handle a full window differently:

Interface	Documented signal	What to check
Kimi native Chat Completions	`invalid_request_error` if input plus requested cap exceeds context	Reduce input or requested cap before retrying
DeepSeek native Chat Completions	`finish_reason: length` can indicate the output cap or context limit	Compare the requested cap, usage, and retained input
OpenAI Responses	`status: incomplete`, with `incomplete_details.reason: max_output_tokens`	Check reasoning usage as well as visible output
Claude Messages, Claude 4.5 and newer	Input alone beyond context is rejected; generation reaching the boundary can stop with `model_context_window_exceeded`	Distinguish an oversized prompt from exhaustion during generation

These are endpoint-specific contracts, not interchangeable field names.^[3]^[5]^[11]^[8]

An agent application can also stop before a model reaches its limit. Preserve the raw provider response alongside the application's error and configured budgets. A message such as “output token limit reached” does not, by itself, identify whether the provider, SDK, or agent imposed the boundary. For DeepSeek-specific budgeting, the existing 1M context guide covers the shared-window calculation.

FAQ

Can I submit 1M input tokens and still receive the maximum output?

Do not assume so. DeepSeek constrains the input and generated output together. Kimi checks input plus the requested cap. Claude's window also includes generated output and thinking. Read the chosen endpoint's rule before packing the prompt to its advertised capacity.^[5]^[3]^[8]

Is the largest output cap the best model for a long report?

It establishes whether the requested allowance is possible under that interface. It does not measure factual accuracy, instruction following, or how much useful text the task needs. Evaluate a representative report and its completion criteria after checking the limit.

Does streaming raise the token ceiling?

The limits in this comparison are generation limits. Streaming changes how you receive a response; it is not the batch-only extension that raises Claude's cap to 300,000. Select that feature explicitly when it is appropriate.^[9]

Should I copy 4096 or 8192 from an example as the model's default?

An example shows a request the author chose to send. Use a default only when the endpoint's specification explicitly labels it. MiniMax's 131,072 is a recommendation; Moonshot explicitly documents Kimi's 131,072 as a native default.^[2]^[3]

Can a response run out of output tokens without producing an answer?

Yes for the OpenAI Responses behavior documented here: reasoning can consume the budget before visible output appears. Inspect the incomplete status and token usage instead of treating an empty answer as evidence that no work occurred.^[11]

What should I store for a production check?

Store the model ID, endpoint, requested output cap, effort setting, reported input/output usage, finish or stop reason, and whether the result passed your task's completion checks. Record these together. They let you compare LLM max output tokens against the budget your application actually used.

Choose a budget before choosing a model

Compare LLM max output tokens against one representative task: the input you must keep, the generation budget you need, and whether you can use a batch interface. Set the cap explicitly, run a small evaluation, and check completion quality alongside token usage. If the task needs more than one call, split it at a meaningful document or code boundary and keep the necessary state for the next request. A larger advertised window alone does not resolve an output limit.