GPT-5.6 Luna: when a low-cost model is enough for bulk tasks

GPT-5.6 Luna costs $0.10 per 1M input and $0.10 per 1M output tokens on Zukko, one of the lowest prices in the catalog. It is worth considering for bulk tasks: classifying thousands of texts, extracting fields, normalizing data. Below: what GPT-5.6 Luna costs at real volumes and a method that shows whether it is good enough on your data.

GPT-5.6 Luna pricing and its catalog neighbors

From the table alone: Luna costs the same as GLM 5.3 but has a 1M-token window versus 128K. If your input texts are long, that may settle the question before any quality check. The model set changes: the current list is at GET https://api.zukko.pro/v1/models or on the "Models" page in the dashboard↗.

Cost at real volumes

Scenario 1: classifying 100,000 texts, 500 input and 50 output tokens each.

Difference at this volume: Sol vs Luna is $16.50 − $5.50 = $11.00; Luna vs Flash is $5.50 − $2.20 = $3.30.

Scenario 2: 1,000,000 such requests (500M input, 50M output tokens).

Here the difference is noticeable: $165 − $55 = $110 between Sol and Luna, $55 − $22 = $33 between Luna and Flash. At these volumes it pays to spend an hour testing a cheaper model.

How to check whether Luna is enough

We do not publish our own accuracy measurements. Only a test on your data answers the question "is Luna enough".

1. Labeled sample. Take 200–300 real texts and label the correct answer by hand. Include edge cases and texts in the languages your system actually handles.
2. Quality bar. Decide in advance what share of correct answers is acceptable and which errors are not.
3. Run. Run the sample on glm-5.3-flash, gpt-5.6-luna and gpt-5.6-sol with the same prompt.
4. Compare. Compute the share of correct answers and look at which texts each model gets wrong.
5. Choose. Pick the cheapest model that meets your bar.

The cost of such a pilot on 300 texts at 500 + 50 tokens for three models: 300 × 550 = 165,000 tokens per model; 0.165 × ($0.04 + $0.10 + $0.30) = $0.0726, under ten cents.

How to call GPT-5.6 Luna

Model ID: gpt-5.6-luna. A classification example with the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.zukko.pro/v1",
    api_key="fetch_your_key",
)

SYSTEM = "Classify the sentiment of the review. Answer with one word: positive, neutral or negative."

reviews = [
    "Great product, fast delivery",
    "Disappointed with the quality, would not recommend",
    "Arrived on time, nothing special",
]

The shorter the answer, the fewer output tokens: ask for one word or compact JSON, not explanations.

Streaming

stream = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[{"role": "user", "content": "List three ways to normalize a postal address"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

The if chunk.choices check is needed: the last chunk may carry token usage data with an empty choices list.

Error handling

import openai

try:
    response = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[{"role": "user", "content": "..."}],
    )
except openai.APIStatusError as e:
    if e.status_code == 402:
        print("Insufficient balance")
    elif e.status_code == 429:
        print("Too many requests: retry with a pause")
    else:
        print(f"Error {e.status_code}: {e.message}")

Cascade: cheap model first, pricier one for hard cases

If Luna meets your bar on some text types but not all, you do not have to move everything to Sol. Send each request to Luna first, and to Sol only when the answer fails an automatic check (wrong label, invalid JSON, empty field).

VALID = {"positive", "neutral", "negative"}

def classify(text: str) -> str:
    for model in ["gpt-5.6-luna", "gpt-5.6-sol"]:
        r = client.chat.completions.create(
            model=model,
            max_tokens=10,
            messages=[{"role": "system", "content": SYSTEM},
                      {"role": "user", "content": text}],
        )
        label = (r.choices[0].message.content or "").strip().lower()
        if label in VALID:
            return label
    return "needs_review"

Cascade cost: all requests are billed at Luna's price, plus a share p of retries at Sol's price. For scenario 1 with p = 5% (measure your own share):

Keep in mind: a cascade only catches errors visible to an automatic check. If Luna confidently returns a wrong but valid label, the cascade will not notice, so the labeled pilot is still necessary.

More on request parameters in the Chat Completions reference↗. If you do not have a key yet, create one under API keys↗.

FAQ

Is Luna faster or slower than Sol?

We do not publish speed measurements. Measure on your own requests: send 20 identical requests to each model and compare the median response time. For batch processing, throughput under parallel requests usually matters more, so test that at your volume too.

Do I need manual review if I classify a million texts?

Yes, on a sample. After launch, regularly check a random sample of a few hundred results and compare the error rate with what you saw in the pilot. If it grows, your data has changed and the model choice should be revisited.

How do I fix Luna's errors cheaply?

Rerun only the disputed records on a pricier model, via the cascade or based on sample review. The cost follows the formula above: Luna's price for the full volume plus Sol's price for the share of retries.

How does Luna handle Russian?

Test it on your sample: include texts in every language present in your data and compute accuracy separately for each language. We have no general estimates.