Quale modello entra in un documento da 100K token: limiti di contesto e di output

Risposta breve: un documento da 100K token entra in uno qualsiasi dei tre modelli in una sola richiesta. Ciò che li distingue è lo spazio che resta intorno. GLM-5.3-Flash ha una finestra di contesto di 390K, DeepSeek-V4-Flash ne ha 380K e può scrivere fino a 32.768 token in risposta, MiniMax-M2.7 ha 180K. Due controlli ti dicono quale usare: il documento e la risposta entrano nella finestra, e la risposta rientra nel limite di output del modello.

I limiti qui sotto sono quelli di CheapTokens, verificati il 1 novembre 2026, e sono quelli con cui viene misurata la tua richiesta quando chiami https://api.cheaptokens.dev/v1. La documentazione mostra come connettersi, e il listino prezzi contiene l'elenco completo dei prezzi.

Il controllo in due passaggi#

Entrambe le regole usano numeri che puoi conoscere prima di inviare qualsiasi cosa:

1. Token di input + max_tokens ≤ finestra di contesto. Il documento e la risposta condividono un'unica finestra.
2. max_tokens ≤ limite di output del modello.

L'ultima colonna è la finestra meno la risposta più lunga, leggendo K come 1.000: 390.000 − 8.192 = 381.808; 380.000 − 32.768 = 347.232; 180.000 − 8.192 = 171.808. In pratica raramente chiedi la risposta più lunga possibile, quindi hai più spazio di quanto mostri quella colonna.

Ecco il controllo su un caso realistico. Hai un log da 200.000 token e vuoi un'analisi da 2.000 token: 200.000 + 2.000 = 202.000. Entra nelle finestre da 390K e 380K e non entra in quella da 180K. Stesso log, stessa domanda, e uno dei tre è già escluso.

Quanto è grande davvero il tuo documento?#

Le pagine sono un'unità di misura scarsa, i token sono quella reale. Supponiamo che una pagina in inglese sia circa 600 token (un'ipotesi; le pagine reali vanno all'incirca da 500 a 700). Allora un documento da 100K token è 100.000 ÷ 600 ≈ 167 pagine. È un contratto corposo o un lungo rapporto annuale, ed entra in ogni modello della tabella con spazio in abbondanza.

La stima in pagine serve per la pianificazione. Prima di inviare, conta i token con un tokenizer, oppure usa la regola approssimativa di circa quattro caratteri per token per l'inglese. Ogni modello ha il proprio tokenizer, quindi un conteggio è una stima, e dopo la richiesta il campo usage della risposta fornisce i numeri esatti.

Esegui il controllo nel codice#

Questo script verifica un contratto rispetto ai limiti sopra, lo invia e stampa come è terminata la risposta. Imposta prima CHEAPTOKENS_API_KEY, e cambia l'id del modello per provare gli altri.

import os
from openai import OpenAI

# context window, max answer tokens (CheapTokens, checked 1 Nov 2026)
LIMITS = {
    'zai-org/GLM-5.3-Flash': (390_000, 8_192),
    'deepseek-ai/DeepSeek-V4-Flash-0731': (380_000, 32_768),
    'MiniMaxAI/MiniMax-M2.7': (180_000, 8_192),
}

def fits(model, input_tokens, max_tokens):
    context, out_limit = LIMITS[model]
    return max_tokens <= out_limit and input_tokens + max_tokens <= context

client = OpenAI(
    base_url='https://api.cheaptokens.dev/v1',
    api_key=os.environ['CHEAPTOKENS_API_KEY'],
)

text = open('contract.txt', encoding='utf-8').read()
estimate = len(text) // 4   # rough: about 4 characters per token in English
model = 'zai-org/GLM-5.3-Flash'
max_tokens = 1500

if not fits(model, estimate, max_tokens):
    raise SystemExit('Does not fit: pick another model or split the text')

reply = client.chat.completions.create(
    model=model,
    max_tokens=max_tokens,
    messages=[
        {'role': 'system', 'content': 'Summarize contracts in 10 bullet points.'},
        {'role': 'user', 'content': text},
    ],
)
print(reply.choices[0].finish_reason)   # stop = ended on its own, length = cut by max_tokens
print(reply.usage.prompt_tokens, reply.usage.completion_tokens)

Se funziona, la prima riga stampa stop e la seconda mostra quanti token sono entrati e usciti. Se vedi length, la risposta ha raggiunto max_tokens; questo articolo spiega come risolvere. E se la richiesta viene rifiutata per dimensioni, request too long: 400 vs 413 la analizza nel dettaglio.

Quanto costa un singolo job da 100K#

Supponiamo che tu riassuma contratti. Ognuno è di 100.000 token e il riassunto è di circa 1.500 token (ipotesi, modificale per adattarle ai tuoi file). La tabella qui sotto è live: si ricalcola dai prezzi attuali e mette il riferimento OpenRouter accanto al nostro.

Il documento è la parte costosa qui, dato che invii molto più di quanto ricevi. Per un singolo job di questo tipo i totali sono $0.0021 su GLM-5.3-Flash, $0.0017 su DeepSeek-V4-Flash e $0.0052 su MiniMax-M2.7. Contando input e output insieme, tutti e tre risultano più economici di OpenRouter. I prezzi sono fissi per modello e senza fasce orarie, quindi un batch notturno costa quanto uno diurno.

Ora rapportalo alla tua giornata. Sposta i cursori sul tuo carico e leggi il totale:

Quando la risposta è la parte lunga#

I riassunti sono il caso facile: una risposta breve entra ovunque. I problemi iniziano quando il modello deve scrivere molto. Supponiamo che tu abbia un manuale da 20.000 token e chieda un report da 6.000 token basato su di esso. Entra in ogni modello (6.000 ≤ 8.192), e la tabella live mostra il costo:

Ora chiedi una traduzione completa dello stesso manuale. Una traduzione dura all'incirca quanto l'originale, quindi ti serve spazio per circa 20.000 token di risposta. Imposta max_tokens a 25.000: 20.000 + 25.000 = 45.000, ben dentro la finestra da 380K, e 25.000 ≤ 32.768, quindi DeepSeek-V4-Flash la gestisce in una sola risposta. Un singolo job così costa $0.0023. Per i modelli con un limite di risposta di 8.192 token, suddividi il manuale in capitoli e inviali uno alla volta.

Quale per il tuo caso#

Se sei ancora incerto, fai passare un documento reale dallo script e leggi usage. Per un confronto più ampio dei tre modelli per attività, vedi GLM vs DeepSeek vs MiniMax, e la pagina DeepSeek tratta DeepSeek-V4-Flash in maggior dettaglio.