Model comparisons · 2026-10-28
What is Giotto Alto? API pricing, per-request cost and reasoning levels
Use Giotto Alto, the model from Swiss company Giotto.ai, through LLMTR: input and output pricing, the roughly 8,000-token instructions added to every request, medium and high reasoning, and a first request.
Short answer: what is Giotto Alto?
Giotto Alto is the main model of Giotto.ai, a company based in Lausanne. On LLMTR it is called as giotto/giotto-alto with your existing LLMTR API key through the OpenAI-compatible POST /v1/chat/completions endpoint; no separate Giotto account is needed.
The model accepts text and image input and returns text. You can send an image in image_url as base64 or as an https address. The context window is 120,000 tokens. Requests are processed by a third-party provider, Giotto.ai; read the provider's terms before sending confidential data.
Pricing and limits
Prices are per 1M tokens. This model has no cache price: every input token in a request bills at the same input price. Reasoning tokens count as output tokens.
| Field | Giotto Alto |
|---|---|
| Input | $2.5862 |
| Output | $12.931002 |
| Context | 120,000 tokens |
| Input types | Text, image |
| Reasoning levels | medium, high |
Cost: a base of about 8,000 tokens on every request
Giotto Alto adds its own instructions to every request. They come to about 8,000 input tokens and bill on top of your message. Even a one-word question costs about $0.02, because 8,000 × 2.5862 / 1,000,000 is about that much.
As an example, take a 500-token message and a 400-token reply. Input is 8,000 + 500 = 8,500 tokens and output is 400 tokens: (8,500 × 2.5862 + 400 × 12.931002) / 1,000,000 is about $0.027. If you plan to send many short requests, remember that the fixed instructions are the main cost item.
The model may not solve a request in one step; if it takes several steps, for example web lookups, each step bills separately and the cost grows with the number of steps. Read the real amount from the usage field of each response and compare your estimate against it, and adjust your budget to real usage.
Reasoning: medium and high
reasoning_effort has two values: medium (the default) and high. At high, the model checks its answer before returning it. This is slower and, in practice, uses roughly twice the tokens of the same request at medium; the cost rises by the same proportion.
Reasoning cannot be turned off. Values such as none or low are not supported. Try high where accuracy matters and slowness does not; start with medium for everything else.
Unsupported features and response behavior
Function tools (tools), response_format, stop, n greater than 1 and logprobs are not supported. temperature, top_p and max_tokens are not applied: LLMTR removes these fields from your request and lists them in the llmtr_dropped_parameters field of the response. For that reason you cannot cap the length of an answer.
Personal tools tied to the account (memory, calendar, mail, Slack, document search) are not available through LLMTR; a request that tries to use them is refused.
The answer arrives in one piece. Even with stream: true, the full answer is sent when it is ready. A reply can take from a few seconds to a minute or more; set your client's timeout accordingly.
When it fits, and when it does not
Because the fixed instructions bill again on every request, Giotto Alto is more efficient with few, content-rich requests. Sending a long document or several related questions in one request is noticeably cheaper than sending the same questions separately; each separate request pays the 8,000-token base again.
High-volume short classification, instant chat, or work where the answer length must be capped does not suit this model: the base cost is high, response time varies, and output cannot be restricted with max_tokens. For agents that call function tools, choose another model.
To test a request with an image, add an image_url part to the message content and, on your first try, look at how the input count in the usage field grows. Before you put its results into production, measure accuracy on your own sample data.
First request: Chat Completions
The request goes to https://llmtr.com/v1/chat/completions with your LLMTR API key. In the OpenAI SDK you only change the base_url and the model ID.
On your first try, read the usage field in the response: the input count includes the instructions, and the charge is computed from those counts. See the Giotto guide for details.
A Giotto Alto request for POST /v1/chat/completions
{
"model": "giotto/giotto-alto",
"reasoning_effort": "medium",
"messages": [
{
"role": "user",
"content": "Summarize this contract clause in two sentences."
}
]
}Frequently asked questions
How much does the Giotto Alto API cost?
Input is $2.5862 and output is $12.931002 per 1M tokens. There is no cache price. Every request also includes the model's instructions of about 8,000 tokens, which bill at the input price.
Does Giotto Alto support tool calling and temperature?
No. Function tools, response_format, stop and logprobs are not supported. temperature, top_p and max_tokens are not applied; LLMTR removes them and reports them in llmtr_dropped_parameters.
Can I turn reasoning off on Giotto Alto?
No. reasoning_effort accepts only medium (the default) and high. At high the model checks its answer, is slower and uses roughly twice the tokens.