Unbiased Pareto

Pareto is Unbiased's blended model: you send one request to a single model id and get one answer. On LLMTR it is called through /v1/chat/completions; it takes text and image input and returns text.

Model	Context	Max output	Input / Cache read / Output ($/1M)
`unbiased/pareto`	262,144	131,072	2.5 / 0.25 / 7.5

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "unbiased/pareto",
    "messages": [
      { "role": "user", "content": "Find the bug in this function." }
    ],
    "max_tokens": 4096
  }'

from openai import OpenAI

client = OpenAI(base_url="https://llmtr.com/v1", api_key="llmtr-your_key")

response = client.chat.completions.create(
    model="unbiased/pareto",
    messages=[{"role": "user", "content": "Find the bug in this function."}],
    max_tokens=4096,
)
print(response.choices[0].message.content)
print(response.usage)

Image input

Images are sent as image_url parts; both base64 data URLs and https:// URLs are accepted.

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "unbiased/pareto",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What does the error message in this screenshot say?" },
          { "type": "image_url", "image_url": { "url": "https://example.com/screenshot.png" } }
        ]
      }
    ],
    "max_tokens": 1024
  }'

A remote URL is fetched by the provider. If your host blocks automated requests or the URL is not publicly reachable, the request fails; send the image as a data URL in that case.

Audio, video and document input are not supported.

Tool calling

Tool calling works with tool_choice: "auto" or with no tool_choice at all. A single response can carry more than one tool call; your client should handle the whole message.tool_calls array. A result you return with role: "tool" is read, and over streaming the tool call arrives in the standard chunks.

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "unbiased/pareto",
    "messages": [
      { "role": "user", "content": "What is the weather in Istanbul?" }
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Gets the current weather for a city",
          "parameters": {
            "type": "object",
            "properties": { "city": { "type": "string" } },
            "required": ["city"]
          }
        }
      }
    ],
    "tool_choice": "auto",
    "max_tokens": 1024
  }'

Other `tool_choice` values are refused

On this model no form of tool_choice other than auto is applied. LLMTR refuses these requests with a 400 before they reach the provider; a refused request is not billed.

What you send	Result	What to do
`tool_choice: "required"`	400	Use `auto` and say in the prompt when the tool should be called.
A named function (`{"type": "function", "function": {"name": "..."}}`)	400	The same: use `auto` and name the tool you want in the prompt.
`tool_choice: "none"` while `tools` is present	400	Leave out the `tools` field when you do not want a tool used.

auto is not a guarantee: the model can also answer in plain text without calling a tool. If your loop depends on a tool call, check for the presence of message.tool_calls.

This affects libraries that get structured output by forcing a tool call (for example LangChain with_structured_output and the Vercel AI SDK's toolChoice: "required"). For structured output on this model use the json_object format below.

JSON output

response_format: { "type": "json_object" } is supported and the answer comes back as a JSON object. Describe the field names and types in the prompt, and validate the answer on your side.

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "unbiased/pareto",
    "messages": [
      { "role": "user", "content": "Tell me about Ankara. Return JSON with the fields city (string) and population (integer)." }
    ],
    "response_format": { "type": "json_object" },
    "max_tokens": 512
  }'

The json_schema format (schema-enforced structured output) is not supported on this model; do not send it.

Prompt cache

Repeated prompt prefixes are cached automatically; there is no field to send. The number of tokens read from the cache arrives in usage.prompt_tokens_details.cached_tokens and is part of the prompt_tokens total. Those tokens are billed at the cache-read rate and the rest at the input rate.

To benefit from the cache, put the content that does not change (system message, tool definitions, a fixed document) at the start of the prompt and the content that changes at the end. There is no guarantee about how long a cache entry is kept.

Token counts and cost

Billing follows the numbers in the usage field of each response. On this model prompt_tokens and completion_tokens for the same prompt can differ between calls, and the completion_tokens of a short answer can be larger than the visible text. Do not estimate cost from prompt length or from your own token count; read the usage field of each response.

Streaming

stream: true is supported. Send stream_options: { "include_usage": true } and usage arrives in the final chunk. Chunks can arrive in a burst towards the end of the response rather than as generation progresses; allow for that if you set a timeout on the time to the first chunk.

Parameters

Field	Behaviour
`max_tokens`, `max_completion_tokens`	Limits the output; a response that reaches the limit ends with `finish_reason: "length"`. A value above 131,072 is refused with a 400.
`reasoning_effort`	Not supported; a request that sends it is refused with a 400. The model has no separate reasoning output.
`temperature`, `top_p`	Accepted. This page makes no claim about their effect on the output.

Model version

unbiased/pareto is an unversioned id: the provider updates the model version behind it on its own side. The same id can answer differently over time; write tests that depend on behaviour accordingly.

Data

Requests are processed on third-party infrastructure outside Turkey; prompts and completions may be logged by the provider. This is not a Turkey-hosted LLMTR model.