· reAPI Team
OpenRouter empty response charged? Read the usage record first
An OpenRouter empty response can hide billed reasoning or a client failure. Check finish reasons, usage, zero completion protection and auxiliary charges.

The answer is blank, but usage.cost is not zero. Before disputing the charge or sending the prompt again, look at the rest of that response. An empty content field does not tell you whether the model produced no tokens, spent its budget reasoning, or returned something your interface did not display.
That distinction matters on OpenRouter. Its Zero Completion Insurance covers particular failed generations, while reasoning can be billable without a visible answer. Both can leave an empty chat bubble. The finish reason and usage record separate them.[1][2]
The missing answer can be in the token count
Here is an illustrative excerpt from a Chat Completions response. The numbers are invented, no request was run, and fields unrelated to this explanation are omitted. It shows the documented pattern in which reasoning consumes the output allowance:[2]
{
"choices": [
{
"message": { "content": "" },
"finish_reason": "length"
}
],
"usage": {
"completion_tokens": 1200,
"completion_tokens_details": {
"reasoning_tokens": 1200
}
}
}Read the three values together. content contains no answer. length says the generation reached its output limit. The completion count is 1,200, and the reasoning detail accounts for all 1,200. The visible output count in this example is therefore 1,200 minus 1,200: zero. Zero visible text is not zero model output.
On most providers, reasoning and visible output share the request's output budget. OpenRouter counts reasoning as output for billing.[2] A request can consequently use the allowance before it reaches the part you wanted to read. That is an unsatisfactory result for the application, but it is different from the zero-completion condition described by the insurance policy.
The example deliberately omits a dollar amount. Token counts do not determine a price without the applicable model and rate. Find the actual usage.cost in your response or the corresponding generation record rather than assigning this invented example a real model's charge.
Hiding the reasoning does not save those tokens. On Chat Completions, reasoning.exclude: true suppresses returned reasoning while leaving the work and its billing intact. The Responses API ignores that exclusion setting.[2] With no visible answer and the reasoning hidden, the interface can be completely blank even though usage records work performed.
Review the selected model's supported reasoning controls before repeating the request unchanged. A lower supported effort or an appropriate reasoning budget may leave room for an answer. Increasing the total output allowance also permits more work and potentially more cost. Choose the change for the task, and inspect the next result; neither setting is a universal guarantee of useful prose.
A different finish reason changes the billing question
Now consider a different record: completion tokens are zero and the finish reason is blank or null. OpenRouter lists that combination as protected. It also lists an error finish reason as a qualifying condition. For covered requests, prompt, completion and reasoning token charges are zero; the protection is automatic.[1]
Keep those conditions intact. “The app showed nothing” is broader. A normal stop reason, a tool call, a structured result or a client parsing failure needs inspection of the complete payload. None should be silently relabeled as zero tokens with a blank finish reason.
There is a second distinction inside the bill. A protected generation can still have a charge for auxiliary work that already ran, such as search, file parsing, PDF OCR or web fetch. OpenRouter's policy treats those services separately and notes that some failure cases skip their charges too.[1] An attempted tool operation is not proof that a fee was charged; read the actual breakdown.
For example, imagine a document request that completed parsing but then ended with a model error. A record showing zero model-token charges plus a parsing charge asks a different question from one showing a charge for protected model tokens. This is an explanation of the policy boundary, not a report that your document request incurred either amount.
Identify the disputed line before contacting support. If the token charge conflicts with the qualifying finish reason, provide those fields together. If the charge belongs to parsing, investigate what parsing work the record shows and the applicable rule. A screenshot of the total alone cannot distinguish the two.
Bring-your-own-key usage adds another account to check. OpenRouter says the inference provider bills BYOK requests directly.[3] A zero or adjusted amount in OpenRouter does not, by itself, establish that the external provider reversed its own charge. Keep the provider invoice and OpenRouter's records separate when reconciling that request.
Find the fields for the API you actually called
A client built around Chat Completions can appear to lose usage if you switch to Responses without changing the field names it reads. OpenRouter documents different names for the same accounting questions:[4]
| What you need | Chat Completions | Responses |
|---|---|---|
| Input count | usage.prompt_tokens | usage.input_tokens |
| Output count | usage.completion_tokens | usage.output_tokens |
| Reasoning count | usage.completion_tokens_details.reasoning_tokens | usage.output_tokens_details.reasoning_tokens |
| Account charge | usage.cost | usage.cost |
For the Responses version of the output-budget problem, inspect status: "incomplete" and incomplete_details.reason: "max_output_tokens". The response may have reasoning without a message item in its output.[2] Looking only for a Chat Completions message.content field would miss the structure you received.
Preserve absent values as unknown. If the reasoning detail is missing, do not insert zero and conclude that all output tokens were visible. Likewise, a missing usage.cost in your own parsed object may mean the parser discarded it; compare the raw response before deciding the service omitted it.
A useful comparison is to take one saved response through the same display code without submitting another generation. In this local debugging exercise, first inspect the returned object, then the value selected by your parser, then the value passed to the interface. If text exists in the first object but disappears in the second, you have located a client-side loss of information. If the original record contains only the reasoning-budget pattern above, changing the display component cannot supply an answer that was never generated. Keep the original record unchanged so a display fix does not erase the evidence for the charge.
Keep a locally calculated estimate separate from the reported charge. An application may calculate a display value from token counts and a stored price table. That number can be useful, but it is not interchangeable with the request's reported cost. A stale estimate should not overwrite a returned zero, and a missing estimate should not be recorded as free usage.
Current documentation says full usage is returned automatically. The older Chat Completions usage.include and stream_options.include_usage switches are deprecated and have no effect.[4] Adding them will not repair a client parser or recover an event that never reached it.
If the stream ended before the record arrived
A disconnected stream leaves a different gap: the application may never receive the final usage event. OpenRouter says streaming and non-streaming requests use the same token pricing.[3] Streaming changes delivery, not the meaning of missing accounting data.
Save the generation ID as soon as it arrives. For Responses streams, usage appears in terminal completed or incomplete events. If that terminal event is absent, the client cannot infer a zero charge from its absence.[4] Preserve the last event actually received rather than synthesizing a successful or free completion.
HTTP 200 is not sufficient either. Once response headers have been sent, an error can appear in the response body or stream. OpenRouter documents error finish reasons in that situation.[5] Check the event content, not just the status stored by an HTTP logger.
Use the saved ID to retrieve generation metadata and compare it with Activity. The documented lookup provides finish reasons, token information and total cost, along with identifying details about the generation.[6] If no ID reached the client, retain the timestamp, requested model and sanitized request context for support. The record is missing from your trace; its cost remains unresolved.
For a coding client that rejects or loses the stream, the stream-disconnection guide addresses the delivery problem separately. Preserve the billing evidence while investigating that client behavior.
Check earlier steps before replaying the whole turn
A tool-using conversation can have a successful first model call, a completed tool action and a failed final explanation. As a hypothetical example, a file is updated successfully, then the model's summary never reaches the interface. The empty final bubble does not undo the file change or establish that every request in the turn failed.
Associate each generation ID with its own result and charge. Keep the tool's outcome beside the model call that requested it. Before replaying the workflow, inspect whether the action already happened. Repeating the entire turn can create new work while making the original billing question harder to answer.
Also distinguish provider fallback within a request from a new request your application submits. OpenRouter's pricing guidance says attempts that error are not billed for model tokens, with completed auxiliary work considered separately.[3] A fresh client request needs its own record; the previous attempt's protection does not describe its result.
Keep credit-purchase fees outside this comparison. Standard and Business accounts pay by purchasing credits manually or through auto top-up; requests then deduct their costs from that balance. OpenRouter says inference uses the serving provider's list price and charges its platform fee on credit purchases.[3] Whether the route saves money for your workload therefore needs the applicable model price and funding fees, not an assumption that every request is discounted. The OpenRouter pricing guide covers that broader comparison; the amount charged to a card is not the model-token charge for one generation. For this incident, the useful question is precise: which generation, finish reason and line item disagree? If those records agree but the answer never appeared, continue with the output budget, response parser or stream handling that the record points to.
Run the same check on any gateway
The output-budget pattern is not specific to one router. On reAPI, GPT-6 Sol bills reasoning tokens as output, and max_completion_tokens caps reasoning and visible text together, so a budget sized only for the answer can run out before any text appears. In a streamed response, usage arrives in the last data chunk before [DONE].[7]
When comparing providers, send the same saved prompt with the same output budget, then read the finish reason and usage fields in each response rather than the visible text alone. The model catalog lists the available models and current rates.
References
- OpenRouter, Zero Completion Insurance: qualifying conditions, token coverage and auxiliary-service exceptions. Reviewed November 15, 2026.
- OpenRouter, Reasoning Tokens: shared output budgets, incomplete responses and reasoning exclusion. Reviewed November 15, 2026.
- OpenRouter, Pricing: failed attempts, streaming and BYOK billing FAQ. Reviewed November 15, 2026.
- OpenRouter, Usage Accounting: API-specific fields, automatic usage and generation-ID lookup. Reviewed November 15, 2026.
- OpenRouter, Errors and Debugging: response-body and streaming error semantics. Reviewed November 15, 2026.
- OpenRouter, Get request and usage metadata for a generation. Reviewed November 15, 2026. Full source URLs and public snapshots are retained in the research archive.
- reAPI. GPT-6 Sol API reference. Reviewed November 17, 2026. GPT-6 Sol.