---
title: "Elaborazione batch LLM senza Batch API: runner e conti"
description: "Esegui da 10.000 a 1.000.000 di prompt su un’API chat completions senza Batch API: concorrenza, ritmo delle richieste, retry, checkpoint riprendibili e tempi."
url: https://broadrouter.com/it/blog/llm-batch-processing-without-batch-api/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (aggiornato il 2026-11-16).

# Elaborazione batch con LLM senza Batch API: un runner riprendibile

A cura del team di BroadNet Inference · 8 min di lettura · Pubblicato 2026-11-15 · Aggiornato 2026-11-16

Senza una Batch API, il job lo gestisci tu: leggi gli elementi da un file JSONL, limita le richieste in corso al tetto della chiave, distanzia gli avvii sotto il limite al minuto, riprova 429 e 5xx con backoff limitato e aggiungi ogni risultato con il suo ID. Al riavvio salta gli ID già completati. Di solito è il rate limit, non il modello, a decidere quando finisci.

## Punti chiave

-   BroadNet Inference documenta solo chat completions e trascrizioni. Non c’è una Batch API né uno sconto batch, quindi un job massivo è un ciclo di richieste normali.
-   Il tempo totale è elementi ÷ il più lento di due ritmi: limite di richieste in corso ÷ latenza, oppure richieste al minuto. Una chiave a consumo consente 4 richieste in corso e 30 al minuto, quindi con un elemento per richiesta il massimo è 43.200 al giorno.
-   Scrivi una riga di risultato per elemento, con il suo ID come chiave, e fai il flush. Quella riga è il checkpoint: un crash costa al massimo le richieste che erano in corso.
-   Una sessione di un piano esegue una richiesta alla volta. Il suo throughput è 86.400 ÷ i secondi per elemento che misuri, al giorno, per sessione.
-   Se il lavoro può aspettare un giorno e uno sconto batch del 50% conta, le Batch API di OpenAI e Anthropic potrebbero costare meno. Fai i conti per entrambe le strade.

**In questa pagina**

1.  BroadNet Inference ha una Batch API?
2.  Quanto tempo richiederà il job?
3.  Com’è fatto un runner riprendibile?
4.  Perché un pool di worker e non asyncio.gather?
5.  Come restano sicuri i retry?
6.  Come funziona il checkpointing?
7.  Quanto costa: pagamento a consumo o sessione di un piano?
8.  Dove si colloca BroadNet Inference

Alcuni job con gli LLM non sono chat. Hai 50.000 ticket di assistenza da etichettare, 200.000 descrizioni di prodotto da tradurre o un milione di recensioni da valutare. Provider come OpenAI e Anthropic vendono per questo una [Batch API](https://broadrouter.com/it/glossary/batch-api/). Molte API compatibili con OpenAI, tra cui BroadNet Inference, non ce l’hanno. Questo articolo mostra come gestire il job da solo: calcolare quanto tempo richiederà, scrivere un runner che rispetti i limiti e renderlo sicuro da fermare e riavviare.

BroadRouter è il sito di BroadNet, quindi i numeri degli esempi usano i limiti pubblicati da BroadNet. Il metodo funziona con qualsiasi API chat completions; sostituisci i numeri del tuo provider.

## BroadNet Inference ha una Batch API?

No. Il [riferimento API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-batch-processing-without-batch-api&utm_content=body), verificato il 15 novembre 2026, documenta `POST /v1/chat/completions`, `POST /v1/audio/transcriptions` e `GET /v1/models` (l’elenco dei modelli), più gli endpoint dell’account sotto `/portal/`. Non c’è un endpoint di batch o di caricamento file, né uno sconto batch. Un job massivo è un ciclo di richieste normali.

Ecco cosa ti dà una Batch API gestita, così sai cosa stai ricostruendo:

|  | Batch API di OpenAI | Message Batches di Anthropic | Il tuo runner |
| --- | --- | --- | --- |
| Prezzo | 50% in meno rispetto alle chiamate sincrone | 50% in meno | Prezzo normale |
| Tempi di consegna | Entro 24 ore | La maggior parte entro 1 ora; scadenza dopo 24 | Dipendono dai tuoi rate limit |
| Dimensione per batch | 50.000 richieste o 200 MB | 100.000 richieste o 256 MB | Qualsiasi |
| Rate limit | Separati dai limiti per modello | Si applicano alle richieste in coda | I limiti della tua chiave |
| Ordine dei risultati | Può variare; abbina con `custom_id` | Abbina con `custom_id` | Tu indicizzi i risultati per ID |

Due lezioni valgono anche per te. Entrambi i provider ti fanno etichettare ogni richiesta con un ID, perché i risultati non tornano in ordine. Nessuno dei due promette una risposta in pochi secondi. Il tuo runner dovrebbe funzionare allo stesso modo: ID su tutto e una pianificazione misurata in ore.

Se uno sconto del 50% conta più dei tempi di consegna, e i modelli che ti servono sono disponibili, una Batch API gestita potrebbe essere lo strumento più economico. Fai i conti per entrambe le strade con il [calcolatore dei costi delle API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/) prima di costruire.

## Quanto tempo richiederà il job?

Calcolalo prima di scrivere codice. Due limiti fissano il throughput, e vince il più lento:

-   **Limite di richieste in corso ÷ latenza.** Con 4 richieste in corso e 2 secondi per richiesta, ne completi 2 al secondo.
-   **Richieste al minuto.** A 30 al minuto puoi avviarne 0,5 al secondo, per quanto veloce sia il modello.

Una chiave BroadNet a [pagamento a consumo](https://broadrouter.com/it/glossary/pay-as-you-go/) consente 4 richieste in corso e 30 al minuto. Con i valori del riferimento API al momento della verifica (30 al minuto e 4 in corso, 2026-11-15), il vincolo è il [rate limit](https://broadrouter.com/it/glossary/rate-limit/), a meno che ogni richiesta non richieda più di 8 secondi, e la tabella qui sotto usa 30 al minuto:

| Elementi | Un elemento per richiesta | 20 elementi per richiesta |
| --- | --- | --- |
| 10.000 | 5,6 ore | 17 minuti |
| 100.000 | 2,3 giorni | 2,8 ore |
| 1.000.000 | 23 giorni | 28 ore |

A 30 richieste al minuto, una chiave fa 1.800 richieste all’ora, cioè 43.200 al giorno. Anche i retry contano: ogni 429 che provochi consuma uno slot.

La seconda colonna è la leva più potente. Gli elementi brevi, come recensioni o oggetti dei ticket, possono andare da 10 a 50 per richiesta sotto forma di elenco numerato, con un array JSON in risposta. Verifica che l’array abbia una voce per ogni input e che ognuna riporti il suo numero. L’[articolo sulla classificazione di testi in arabo](https://broadrouter.com/it/blog/arabic-text-classification-llm/) mostra lo schema. Gli elementi lunghi non si possono raggruppare: ogni richiesta deve comunque stare nella [finestra di contesto](https://broadrouter.com/it/glossary/context-window/) del modello, e la qualità può calare man mano che l’elenco cresce. Prova il raggruppamento su 200 elementi prima di fidarti.

Non dividere un job su più chiavi per superare un limite per chiave senza chiedere. La [Policy di utilizzo accettabile](https://www.broadnet.ai/aup) di BroadNet vieta di aggirare i limiti di frequenza, di concorrenza o di budget. Se ti serve di più, chiedi a BroadNet oppure usa le sessioni dei piani, più sotto. Il [pianificatore di job batch](https://broadrouter.com/tools/llm-batch-job-planner/) fa questi conti per il tuo numero di elementi, la tua latenza e i tuoi limiti.

## Com’è fatto un runner riprendibile?

Questo runner legge `items.jsonl` (un oggetto `{"id", "text"}` per riga) e aggiunge una riga di risultato per elemento a `results.jsonl`. Gli serve solo l’SDK Python di OpenAI.

```python
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))
```

Eseguilo con `python batch_run.py items.jsonl results.jsonl`. Abbiamo testato esattamente questo file contro un server mock locale che restituiva 429 casuali (8%) e 500 (5%) e rifiutava tutto oltre 4 richieste in corso o 30 avvii al minuto. 25 elementi sono stati completati in 55 secondi con 28 richieste (3 retry), e mai più di 30 avvii in una qualsiasi finestra di 60 secondi. Con il limite del mock alzato a 300 al minuto per risparmiare tempo, un’esecuzione da 120 elementi interrotta dopo 10 secondi è ripartita da 39 risultati salvati e ha terminato con 120 ID unici e nessun duplicato.

## Perché un pool di worker e non asyncio.gather?

La [guida al 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/) usa un semaphore attorno ad `asyncio.gather`. Va bene per qualche centinaio di chiamate. Per un job grande è meglio un pool fisso di worker che pescano da una coda:

-   **Memoria.** `gather` crea in anticipo un task per ogni elemento. Un pool tiene in memoria solo gli elementi in corso.
-   **La concorrenza è la dimensione del pool.** Quattro worker non possono mai avere cinque richieste aperte.
-   **I risultati vanno su disco in streaming** man mano che finiscono, in qualsiasi ordine, con l’ID come chiave.

Il `Pacer` gestisce il secondo limite. Un semaphore da solo ti impedisce di superare le 4 richieste in corso, ma se le richieste durano un secondo, quattro worker ne avvierebbero 240 al minuto e la maggior parte riceverebbe un 429. Il pacer distanzia gli avvii di 2 secondi, su tutti i worker, retry compresi.

## Come restano sicuri i retry?

Riprova solo ciò che può riuscire al secondo tentativo:

| Risposta | Azione |
| --- | --- |
| 429 | Attendi e riprova; la documentazione di BroadNet dice “use response details and bounded backoff” (traduzione: usa i dettagli della risposta e un backoff limitato) |
| 500, 502, 503, 504, timeout, connessioni interrotte | Riprova con backoff esponenziale limitato |
| 400, 422 | Correggi la richiesta; riprovare restituisce lo stesso errore |
| 401, 402, 403 | Ferma il job; chiave, saldo o policy richiedono attenzione |
| 413 | Accorcia l’elemento |

Il runner disattiva i retry dell’SDK (`max_retries=0`) così esiste una sola policy di retry, con un tetto visibile. Il backoff è [esponenziale](https://broadrouter.com/it/glossary/exponential-backoff/) con full jitter, limitato a 60 secondi, così i worker che hanno fallito insieme non riprovano insieme. Dopo sei tentativi l’elemento viene scritto come `"ok": false` e il job va avanti. Un solo elemento difettoso non blocca mai un milione.

Una chiamata al modello non ha effetti collaterali, quindi qui la consegna è almeno una volta: se il processo muore a metà richiesta, quell’elemento viene inviato di nuovo al riavvio e lo paghi due volte. È l’unico spreco. Se il job scrive anche su un altro sistema, come ticket o email, rendi quella scrittura [idempotente](https://broadrouter.com/it/glossary/idempotency-key/) in base all’ID dell’elemento e falla in un passaggio separato su `results.jsonl`. L’[articolo sugli agenti a lunga esecuzione](https://broadrouter.com/it/blog/long-running-agents-timeouts-retries/) approfondisce gli effetti collaterali idempotenti.

## Come funziona il checkpointing?

Il file di output è il checkpoint. Ogni elemento completato è una riga già scritta su disco con il flush, quindi dopo un crash, un deploy o un Ctrl-C l’esecuzione successiva legge il file, raccoglie gli ID con `"ok": true` e mette in coda solo il resto. Gli elementi falliti in precedenza vengono riprovati all’esecuzione successiva, e la loro nuova riga viene aggiunta in fondo. Quando leggi i risultati, prendi l’ultima riga per ogni ID.

Tre abitudini rendono il sistema solido per giorni:

1.  **ID stabili.** Usa una chiave del database o un hash dell’input, mai un numero di riga che si sposta quando il file di input cambia.
2.  **Controlla `finish_reason`.** Una risposta troncata a `max_tokens` è `"ok": true` ma inutile. DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B ragionano prima di rispondere, e [il ragionamento conta in max\_tokens](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/). Il runner imposta `reasoning_effort="low"`, documentato da BroadNet, e lascia 1.500 token.
3.  **Registra l’utilizzo su ogni riga.** Sommando `usage` da `results.jsonl` ottieni la vera bolletta dei token da confrontare con la tua stima.

## Quanto costa: pagamento a consumo o sessione di un piano?

Con il pagamento a consumo il costo sono i token. Prendi 100.000 recensioni, un system prompt da 150 token, una recensione da 150 token e 100 token di output con ragionamento basso. Fanno 30 milioni di token di input e 10 milioni di output. Su [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) costa 30 × $0.175 + 10 × $0.52. Tieni il system prompt per primo e identico byte per byte, e i suoi 15 milioni di token possono essere fatturati alla tariffa dell’[input in cache](https://broadrouter.com/it/blog/cached-input-tokens-explained/) di $0.0055 per 1M dove la cache funziona. Le tue righe `usage` mostrano quanto spesso è successo.

Con un piano i token sono gratuiti e il costo è il tempo. Una sessione di un piano DeepSeek V4.1 Flash “runs one request at a time” (traduzione: esegue una richiesta alla volta), quindi imposta `IN_FLIGHT=1` per sessione. Il throughput per sessione è 86.400 ÷ secondi per elemento, al giorno. BroadNet indica come velocità tipica circa 100 token al secondo, ma la tua latenza dipende dalla lunghezza del prompt e dal ragionamento, quindi misurala su 50 elementi. Se misuri 3 secondi a elemento, una sessione ne fa 28.800 al giorno:

| Job | Sessioni | Tempo a 3 s/elemento | Piano |
| --- | --- | --- | --- |
| 100.000 elementi | 1 | Circa 3,5 giorni | Una settimana Orbit, $15 per sessione |
| 100.000 elementi | 4 | Circa 21 ore | Quattro settimane Orbit, una per sessione; oppure circa 21 ore Meteor per sessione a $1 l’una |
| 1.000.000 di elementi | 6 | Circa 6 giorni | Sei settimane Orbit |

I piani sono forniti “best effort under fair use” (traduzione: al meglio delle possibilità, secondo il fair use), e BroadNet non pubblica un limite di richieste al minuto per le chiavi dei piani; il tuo account mostra i limiti che si applicano. Imposta `RPM` in base a quelli, non a occhio. La [guida al pianificatore di sessioni](https://broadrouter.com/it/guides/unlimited-llm-api-sessions/) spiega come distribuire le sessioni tra le chiavi.

## Dove si colloca BroadNet Inference

BroadNet Inference non ha una Batch API, quindi è adatto ai job massivi quando preferisci controllare tu il runner e pagare i normali prezzi a token, oppure fissare il costo con le sessioni dei piani DeepSeek V4.1 Flash. Per job piccoli con poco budget, [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/) a $0.10 di input e $0.22 di output per 1M funziona con il credito iniziale di $5. Prompt e output non vengono conservati dopo ogni richiesta. Se il tuo job può aspettare un giorno e i modelli che ti servono sono su un provider con uno sconto batch del 50%, potrebbe costarti meno; confronta prima di impegnarti. Piani e limiti sono su [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-batch-processing-without-batch-api&utm_content=body).

Strumenti gratuiti sul tema (in inglese)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Rate limit (limite di frequenza)](https://broadrouter.com/it/glossary/rate-limit/)

Un rate limit è un tetto che un’API pone a quanto un client può usarla in un intervallo di tempo, per esempio richieste al minuto o token al minuto. Le richieste oltre il limite vengono rifiutate, di solito con HTTP 429 Too Many Requests, finché l’uso non torna sotto la soglia.

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

[Batch API](https://broadrouter.com/it/glossary/batch-api/)

Una batch API è un endpoint LLM asincrono che accetta molte richieste insieme, di solito come file, le elabora entro una finestra prestabilita invece che subito, e restituisce i risultati tutti insieme. Provider come OpenAI e Anthropic applicano alle richieste batch uno sconto rispetto alle loro API standard.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Throughput](https://broadrouter.com/it/glossary/throughput/)

Il throughput, nel serving di LLM, è la quantità totale di lavoro che un sistema completa per unità di tempo su tutte le richieste concorrenti, di solito misurata in token di output al secondo o richieste al secondo. È diverso dalla velocità per stream, cioè quanto rapidamente una singola richiesta riceve i suoi token.

[Backoff esponenziale (exponential backoff)](https://broadrouter.com/it/glossary/exponential-backoff/)

Il backoff esponenziale è una strategia di retry in cui un client aspetta sempre di più dopo ogni tentativo fallito, di solito raddoppiando il ritardo fino a un tetto, prima di riprovare. Aggiungere un jitter casuale a ogni attesa distribuisce i retry di molti client, così non colpiscono il server nello stesso istante.

[Chat Completions API](https://broadrouter.com/it/glossary/chat-completions-api/)

La Chat Completions API è l’endpoint HTTP di OpenAI, POST /v1/chat/completions, che riceve il nome di un modello e una lista di messaggi con un ruolo e restituisce il messaggio successivo del modello. La forma della sua richiesta e risposta è diventata il formato comune che riusano provider e SDK compatibili con OpenAI.

## Domande frequenti

### BroadNet Inference ha una Batch API?

No. Il suo riferimento API, verificato il 15 novembre 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions e GET /v1/models, senza endpoint di batch o di caricamento file e senza sconto batch. Esegui i job massivi come richieste normali entro i limiti della tua chiave.

### Come elaboro 100.000 prompt con un’API LLM?

Metti gli elementi in un file JSONL, ciascuno con un ID. Avvia un numero fisso di worker pari al limite di richieste in corso della chiave, distanzia gli avvii sotto il limite al minuto, riprova 429 e 5xx con backoff limitato e aggiungi ogni risultato a un file di output con l’ID come chiave, così il job può riprendere.

### Quanto tempo richiede un batch da un milione di richieste?

Dividi gli elementi per il tuo ritmo reale. A 30 richieste al minuto e un elemento per richiesta, una chiave ne fa 43.200 al giorno, quindi un milione richiede circa 23 giorni. Mettere 20 elementi brevi per richiesta riduce il tempo a circa 28 ore, se il modello gestisce bene il prompt più lungo.

### Meglio asyncio.gather o un pool di worker per le chiamate LLM in batch?

Per decine di migliaia di elementi usa un pool fisso di worker che pescano da una coda. gather con un semaphore va bene per job piccoli, ma crea tutti i task in anticipo e rende più difficili la ripresa e il monitoraggio dell’avanzamento.

### Posso usare più chiavi API per andare più veloce?

Verifica prima. La Policy di utilizzo accettabile di BroadNet vieta di aggirare i limiti di frequenza o di concorrenza, quindi chiedi a BroadNet prima di dividere un job su più chiavi per superare un limite per chiave. Mettere più elementi per richiesta e usare le sessioni dei piani sono i modi documentati per aumentare il throughput.

### Un piano flat va bene per i job batch?

Può andare bene, per DeepSeek V4.1 Flash. Una sessione esegue una richiesta alla volta senza contatore di token, quindi il costo è fisso e la questione è il tempo. Misura i secondi per elemento, poi compra abbastanza sessioni da finire entro il periodo.

## Continua a leggere

-   [Errore 429 nelle API LLM: backoff, jitter e limitatori](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/)
-   [Agenti di lunga durata: timeout, retry e checkpoint che reggono](https://broadrouter.com/it/blog/long-running-agents-timeouts-retries/)
-   [Classificare testo arabo con un LLM: sentiment, intenzione, triage](https://broadrouter.com/it/blog/arabic-text-classification-llm/)
-   [Come far girare agenti di coding in parallelo con un’API LLM flat](https://broadrouter.com/it/blog/run-parallel-coding-agents-flat-rate/)
-   [Un piano LLM settimanale per progetti brevi: Orbit, ora o mese](https://broadrouter.com/it/blog/weekly-llm-plan-short-projects/)
-   [Come stimare il costo delle API LLM prima di lanciare una funzione](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Come funzionano i piani API LLM illimitati per gli agenti](https://broadrouter.com/it/guides/unlimited-llm-api-sessions/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-batch-processing-without-batch-api&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: endpoint, limiti a consumo (30 al minuto, 4 in corso), limiti della chiave oraria, indicazioni sui retry per 429 e 5xx, reasoning\_effort (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Pagina dei piani di BroadNet Inference: una richiesta alla volta per sessione, velocità tipica, prezzi dei piani (verificata il 2026-11-15) (in inglese)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Policy di utilizzo accettabile di BroadNet, sezioni 3 e 4: vietato aggirare i limiti di frequenza o di concorrenza; piani best effort secondo il fair use (verificata il 2026-11-15) (in inglese)](https://www.broadnet.ai/aup)
-   [Guida alla Batch API di OpenAI: sconto del 50%, finestra di 24 ore, 50.000 richieste o 200 MB per batch, l’ordine dell’output può variare, custom\_id (verificata il 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Documentazione della Message Batches API di Anthropic: sconto del 50%, 100.000 richieste o 256 MB, la maggior parte dei batch entro 1 ora, scadenza dopo 24 ore (verificata il 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
