Apodex

Apodex offers two models: apodex/apodex-1.1 for complex reasoning and long documents, and apodex/apodex-1.1-mini for high-volume, low-cost work. Both are called through /v1/chat/completions; they take text and image input and produce text.

Model	Context	Max output	Input / Cache read / Output ($/1M)
`apodex/apodex-1.1`	262,144	32,768	0.24 / 0.024 / 2.4
`apodex/apodex-1.1-mini`	262,144	32,768	0.08 / 0.008 / 0.8

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "apodex/apodex-1.1",
    "messages": [
      { "role": "system", "content": "Answer briefly." },
      { "role": "user", "content": "Summarise the termination clauses in this contract." }
    ],
    "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="apodex/apodex-1.1-mini",
    messages=[{"role": "user", "content": "Classify this email as complaint, request or information."}],
    max_tokens=2048,
)
print(response.choices[0].message.content)
print(response.usage)

Long-context pricing

When a request has more than 200,000 input tokens, the whole request (input, cache read and output tokens) is billed at double the rate. The threshold looks at input tokens; 200,000 and below is the standard rate.

Model	Input / Cache read / Output ($/1M), above 200K
`apodex/apodex-1.1`	0.48 / 0.048 / 4.8
`apodex/apodex-1.1-mini`	0.16 / 0.016 / 1.6

If you split large documents so that each request stays under 200,000 input tokens, you are billed at the standard rate.

Reasoning

Both models reason before answering by default. The reasoning text arrives in message.reasoning_content (delta.reasoning_content when streaming), and the answer itself is in content. Reasoning tokens are part of usage.completion_tokens and are billed at the output rate, which is why even a short question can cost hundreds of output tokens.

Switch reasoning off for tasks where you want a direct answer:

What you send	Result
The `:fast` suffix on the model id (`apodex/apodex-1.1:fast`)	Reasoning off
`"reasoning": false`	Reasoning off
The `:think` suffix or `"reasoning": true`	Reasoning on (same as the default)
Neither	Reasoning on

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "apodex/apodex-1.1-mini:fast",
    "messages": [
      { "role": "user", "content": "What is 17 * 23? Reply with the number only." }
    ],
    "max_tokens": 64
  }'

reasoning_effort is not supported; a request that sends it is refused with 400. The amount of reasoning cannot be tuned, only switched on or off.

Image input

Send images as an image_url part; 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": "apodex/apodex-1.1",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What is the total amount and the due date on this invoice?" },
          { "type": "image_url", "image_url": { "url": "https://example.com/invoice.png" } }
        ]
      }
    ],
    "max_tokens": 1024
  }'

The provider downloads remote URLs itself. If your host blocks automated requests or is not publicly reachable, the request fails; send the image as a data URL instead.

Audio, video and document input are not supported.

Tool calling

Tool calling works with tool_choice set to auto, required or a named function ({"type": "function", "function": {"name": "..."}}). A result you send back with role: "tool" is read, and on the streaming path tool calls arrive in the standard chunks. Your client should process the whole message.tool_calls array.

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

With reasoning on, the model also reasons before calling a tool, and those tokens are billed as output too. For loops where the tool choice is simple, consider the :fast suffix.

JSON output

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

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

The json_schema format (schema-constrained structured output) is not supported on these models; do not send it. If you need schema-bound output, you can force a tool with tool_choice: "required" and use its arguments.

Prompt caching

Repeated prompt prefixes are cached automatically; you do not need to send any field for it. The number of tokens read from cache arrives in usage.prompt_tokens_details.cached_tokens and is included in 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 content that does not change (system message, tool definitions, fixed documents) at the start of the prompt and the changing part at the end. The first request carrying a prefix may not read from cache, and there is no guarantee on how long the cache is kept.

Streaming

stream: true is supported. If you send stream_options: { "include_usage": true }, the total usage arrives in the last chunk, whose choices array is empty.

Parameters

Field	Behaviour
`max_tokens`, `max_completion_tokens`	Limits the output; an answer that reaches the limit ends with `finish_reason: "length"`. Values above 32,768 are refused with 400. With reasoning on, this limit covers the reasoning tokens too: at a low value the answer can end with `length` while `content` is empty. Raise the limit or use `:fast` in that case.
`reasoning` (boolean)	Switches reasoning on or off; see the table above.
`reasoning_effort`	Not supported; a request that sends it is refused with 400.

Data

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

Free period

apodex/apodex-1.1-mini-free is the id under which Apodex 1.1 Mini is offered at no charge until 10 October 2026, 23:59 (TRT). It is the same model: the context, output limit, reasoning, image input, tool calling and JSON output described on this page for apodex/apodex-1.1-mini apply to this id too. Only the model field changes, and the request is not billed.

Daily limit. Free use is limited per account per day. When the limit is reached the request is refused with 429, and the Retry-After header gives the time until you can retry, in seconds. Reasoning tokens count toward this limit too; with :fast the same limit covers more requests. If you do not want to wait, send the same request to apodex/apodex-1.1-mini.
End. The period ends on 10 October 2026 at 23:59 (TRT); it closes before that date if the quota set aside for free use runs out. After it closes, requests to this id return 410 (model_retired) and the error message names apodex/apodex-1.1-mini as the id to move to.

For a lasting integration, use apodex/apodex-1.1-mini.