ScaleDown task models

ScaleDown's task models each do one job: summarize a text, pull the fields you describe out of it, or answer typed questions about it. They do not chat; their answers come in a shape your code reads. All three are called with the scaledown/ prefix, exactly as the catalog lists them.

Model	Endpoint	Context	Input / Output ($/1M tokens)
`scaledown/summarize-free`	`/v1/chat/completions`	131,072	0 / 0
`scaledown/extract-free`	`/v1/chat/completions`	131,072	0 / 0
`scaledown/classify-free`	`/v1/systemone`	131,072	0 / 0

Free offer

The three models are free until 20 October 2026, 23:59 (TRT). They close earlier if the quota set aside for free use runs out; all three close together. Free use is limited per account per day.

If your account has never made a payment, requests answer 402 after a short period of use and ask you to verify the account by adding credit once. The models stay free; the amount you add stays in your balance and works with every model.

When the offer ends, requests answer 410 model_retired. Your requests are not forwarded to another model. The model's page lists paid models for the same kind of work, each with its endpoint. The models suggested for classification take the same /v1/systemone request with only model changed. Those suggested for summarization and field extraction may use another endpoint and request shape; follow the example on the chosen model's page.

Summarization

scaledown/summarize-free summarizes the last user message. A system message sets the summary's format, focus or language.

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "scaledown/summarize-free",
    "messages": [
      { "role": "system", "content": "Answer in two bullet points." },
      { "role": "user", "content": "The city council approved a new public transport plan on Tuesday. ..." }
    ]
  }'

The response is a chat.completion object. choices[0].message.content is not plain text but a JSON string; parse it and read its fields:

{
  "summary": "The city council approved a new public transport plan. ...",
  "input_chars": 538,
  "output_chars": 462,
  "input_tokens": 304,
  "finish_reason": "stop",
  "notice": null,
  "ocr_text": null
}

A finish_reason of length means the summary was cut at the output limit, and notice says so. One summary is at most 1,000 tokens; a larger max_tokens returns 400 invalid_request.

import json
from openai import OpenAI

client = OpenAI(base_url="https://llmtr.com/v1", api_key="llmtr-your_key")
response = client.chat.completions.create(
    model="scaledown/summarize-free",
    messages=[{"role": "user", "content": "Text to summarize ..."}],
)
summary = json.loads(response.choices[0].message.content)["summary"]

Field extraction

scaledown/extract-free needs a schema in every request that says what to look for. Send one in response_format with type: "json_schema"; each field under properties is a kind of information to find, described in plain language with description. The last user message is the text to search.

curl "$LLMTR_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "scaledown/extract-free",
    "messages": [
      { "role": "user", "content": "Invoice 2026-118 from Acme Logistics GmbH, issued 3 October 2026, total due EUR 4,250.00." }
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "invoice",
        "schema": {
          "type": "object",
          "properties": {
            "company": { "type": "string", "description": "Company names" },
            "amount": { "type": "string", "description": "Money amounts with currency" },
            "date": { "type": "string", "description": "Dates" }
          }
        }
      }
    }
  }'

choices[0].message.content is a JSON string; read both its entities and structured_result fields. For flat fields each match comes back in the entities list, carrying the text found (text), the field name (type), a confidence (confidence), its position in the text (start, end) and the surrounding text (context), and structured_result is null. When the schema has a nested object or an array of objects, the result comes back in structured_result, shaped like your schema. Filter low-confidence matches in your code or send them for review.

A request without a schema returns 400 invalid_request; the error names the field to add and carries an example. $ref and $defs are not supported in the schema; write each field's definition inline.

Classification

scaledown/classify-free runs on the Structured Decisions endpoint: it takes a state and typed questions, and returns a choice, a score or a yes-probability for each question.

curl "$LLMTR_BASE_URL/v1/systemone" \
  -H "Authorization: Bearer llmtr-your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "scaledown/classify-free",
    "state": "Our API integration started returning 500 errors on every request 20 minutes ago.",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "The message conveys urgency" },
      "team": {
        "type": "choice",
        "instructions": "Which team should handle this",
        "criteria": { "billing": "Payments and refunds", "technical": "Bugs and integrations", "sales": "Pricing and accounts" }
      }
    }
  }'

The state is counted for every question; send only the questions you will use.
A score question takes 2 to 10 levels.
A state or instructions that is an object with only a text key ({ "text": "..." }) is given to the model as that text. Any other object or array is given to the model as its JSON text.

Limits

All three models read text only. A document field, an image in the messages, or an image or PDF in the state returns 400 invalid_request.
There is no tool calling; tools or tool_choice returns 400 invalid_request. Each request returns one answer, so n cannot be above 1.
For summarization and field extraction, stream: true is accepted; the answer is sent in chunks once it is complete, so the first chunk arrives when the answer is done. /v1/systemone does not stream.
The summarization and extraction models are not listed in LLMTR Chat or the Playground; call them through the API.

Errors

Status	Meaning
`400 invalid_request`	The request carries something these models do not accept: extraction without a schema, a document or image, tool calling, a top-level `text`, `instructions` or `entities` field, a `max_tokens` above 1,000 on summarization, a prompt or state above 131,072 tokens, a score question with more than 10 levels. The message says what to change.
`402 insufficient_credits`	`details.reason` is `account_verification_required`: verify your account by adding credit once. The model stays free.
`402 insufficient_quota`	Your account's use for this free offer is used up.
`410 model_retired`	The free offer has ended. Switch to one of the paid models on the model's page.
`429 rate_limit_error`	The daily free-use limit or the API key's request limit was reached. If the response carries a `Retry-After` header, wait that long.
`503 model_unavailable`	The model cannot answer right now; try again shortly.

See Errors for the error format.