Pricing and budget · 2026-10-17
Glimpse reasoning_effort and cost: low, medium, xhigh
On Glimpse, reasoning_effort low, medium and xhigh do not change the token price; reasoning and agent steps bill as output. Worked examples and code.
Short answer: the level changes the token count, not the price
LLMTR is a gateway that gives access to language models from different providers through one OpenAI-compatible API. You call Elorian's Glimpse there with the model id elorian/glimpse on the /v1/chat/completions endpoint at https://llmtr.com/v1. reasoning_effort takes low, medium and xhigh and does not change the price per 1M tokens. What can change is how much the model thinks, and so the number of completion_tokens: reasoning tokens and the agent's steps count in completion_tokens and are billed at the output price.
Elorian announced Glimpse on 16 October 2026 as a research preview and published its price per 1M tokens as $0.60 for input and $3.00 for output. In the LLMTR catalog the price per 1M tokens is $0.60 for input, $0.06 for input read from cache and $3.00 for output.
How does the reasoning level affect cost on Glimpse?
A request's cost comes from three numbers: uncached input tokens at $0.60, input tokens read from cache at $0.06 and completion_tokens at $3.00 (all per 1M tokens). reasoning_effort is not a multiplier in that sum; low and xhigh pay the same unit price. The least thinking happens at low. Because the reasoning tokens spent are added to completion_tokens, longer thinking can mean a higher output cost for the same question.
Rather than guessing the difference from the level's name, read it from usage on your own requests. The Python example below sends the same question at all three levels and, for each response, prints prompt_tokens, the tokens read from cache, completion_tokens and reasoning_tokens, along with an approximate cost computed at the catalog prices. The example sets max_tokens to 512, yet completion_tokens can come out higher. A difference on one question does not generalize; compare a few samples from your own workload.
A Python example (OpenAI SDK) that sends the same question at low, medium and xhigh and prints each response's token counts and approximate cost.
import os
from openai import OpenAI
# LLMTR catalog prices for elorian/glimpse, USD per 1M tokens (17 October 2026)
INPUT_USD = 0.60
CACHED_INPUT_USD = 0.06
OUTPUT_USD = 3.00
client = OpenAI(
base_url="https://llmtr.com/v1",
api_key=os.environ["LLMTR_API_KEY"],
timeout=1800,
)
question = "A train leaves at 14:35 and arrives at 17:10. How long is the trip? Answer in one line."
for effort in ["low", "medium", "xhigh"]:
response = client.chat.completions.create(
model="elorian/glimpse",
messages=[{"role": "user", "content": question}],
reasoning_effort=effort,
max_tokens=512,
)
usage = response.usage
prompt_details = usage.prompt_tokens_details
completion_details = usage.completion_tokens_details
cached = (prompt_details.cached_tokens or 0) if prompt_details else 0
reasoning = (completion_details.reasoning_tokens or 0) if completion_details else 0
cost = (
(usage.prompt_tokens - cached) * INPUT_USD
+ cached * CACHED_INPUT_USD
+ usage.completion_tokens * OUTPUT_USD
) / 1_000_000
print(
f"{effort}: prompt={usage.prompt_tokens} cached={cached} "
f"completion={usage.completion_tokens} reasoning={reasoning} approx_cost=${cost:.6f}"
)Price table and worked examples
A worked example: for a 2,000-token prompt and 1,500 completion_tokens (1,200 of them reasoning), the cost is (2,000 x $0.60 + 1,500 x $3.00) / 1M = $0.0057. Had the same prompt produced 6,000 completion_tokens, the cost would be (2,000 x $0.60 + 6,000 x $3.00) / 1M = $0.0192. The input stayed the same, so the whole difference comes from the output side. The figures are an example; the response's usage tells you how many tokens a level spent. reasoning_tokens is not billed as a separate line, it is part of completion_tokens, so do not add the two when you compute the cost.
On the input side, the cache helps. If you keep a long, fixed prompt prefix identical across requests, the prefix can be read from the cache: when 16,000 of a 20,000-token prompt are read from it, the input costs (4,000 x $0.60 + 16,000 x $0.06) / 1M = $0.00336, against $0.012 without the cache. The cache works automatically with no field to send, and it may not take effect on the very first repeat.
| Item | Price | usage field |
|---|---|---|
| Input (uncached) | $0.60 / 1M tokens | prompt_tokens minus cached_tokens |
| Input read from cache | $0.06 / 1M tokens | prompt_tokens_details.cached_tokens |
| Output (visible answer, reasoning and agent steps) | $3.00 / 1M tokens | completion_tokens |
| Reasoning tokens | output price, $3.00 / 1M tokens | completion_tokens_details.reasoning_tokens (inside completion_tokens) |
How to send the level, and what is refused
You send the level in the reasoning_effort field or as a suffix on the model id: elorian/glimpse:low, elorian/glimpse:medium and elorian/glimpse:max. The max suffix, and max as a reasoning_effort value, apply as xhigh. When a request carries no level, medium applies. The level is chosen per request: sending low for short questions and xhigh for images that need a detailed look, in the same application, takes nothing more than changing one field's value.
high, minimal and none are refused with a 400, and the error message lists the accepted levels. Reasoning cannot be turned off: sending reasoning: false or enabled: false also gets a 400, so use low for the least thinking. The reasoning text is not returned; only its count appears in usage.completion_tokens_details.reasoning_tokens.
max_tokens does not cap the spend
max_tokens (or max_completion_tokens) limits only the visible answer; when you send none, 4,096 applies. The agent's steps and reasoning are added on top of that limit as completion_tokens. In other words, a request that sends max_tokens: 200 can still be billed for far more than 200 completion_tokens. A finish_reason of length means the visible answer reached the limit.
Images and video grow the input side. This row has no separate media price; images and a video's frames count in prompt_tokens and are billed at the input price. A long video uses far more input tokens than a short text request.
To limit the spend, keep the level low and put a spending limit on your API key. The spending limit (USD) caps the total amount the key can spend; once it is exceeded, requests get 402 spending_limit_exceeded. Unsupported fields (tools, a JSON response_format, stop, n above 1 and others) are refused with a 400 before the request reaches the provider, and those requests are not billed. Without streaming, give your client a long timeout; if your connection drops while you wait, the request can still be billed.
Data notice and getting started
This model is served through a third-party provider. The text, images and videos you send may be stored by the provider and used to train Elorian's models. Do not send sensitive, personal or customer data.
To start, create an account at llmtr.com, top up your balance from Dashboard > Billing, and create a key under Dashboard > API Keys, stored in the LLMTR_API_KEY environment variable. You can set the spending limit when you create the key or later with Edit in the key list.
Pick a level on Glimpse and track the cost
Choose reasoning_effort for elorian/glimpse, send the request to https://llmtr.com/v1 and compute the cost from the token counts in usage.
- Choose the level. Set reasoning_effort to low, medium or xhigh; when you send none, medium applies.
- Send the request. Send the same question at two or three levels to https://llmtr.com/v1/chat/completions with elorian/glimpse.
- Read usage. In each response, look at prompt_tokens, cached_tokens, completion_tokens and reasoning_tokens; compute the cost at $0.60, $0.06 and $3.00 per 1M tokens.
Frequently asked questions
Is xhigh more expensive than low on Glimpse?
The unit price is the same: at every level, $0.60 input, $0.06 input read from cache and $3.00 output per 1M tokens. Because the reasoning tokens spent are added to completion_tokens, a request that thinks longer can cost more. Read the real difference from usage.
At what price are reasoning tokens billed?
At the output price, $3.00 per 1M tokens. Reasoning tokens are part of completion_tokens, and their count also appears separately in usage.completion_tokens_details.reasoning_tokens.
Can reasoning be turned off on Glimpse?
No. reasoning_effort takes only low, medium and xhigh; none, minimal and high are refused with a 400. Use low for the least thinking.