---
title: "Failover API LLM su un provider di backup, in Python"
description: "Come fare failover tra provider LLM compatibili con OpenAI: quali errori lo attivano, circuit breaker, mappatura degli ID modello, streaming, costi e privacy."
url: https://broadrouter.com/it/blog/llm-api-failover-fallback/
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-api-failover-fallback/) (aggiornato il 2026-11-16).

# Failover API LLM: passare a un secondo provider nel tuo codice

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

Tieni un elenco ordinato di provider compatibili con OpenAI, ciascuno con il proprio client e il proprio ID modello. Fai failover su errori di connessione, timeout, 5xx e 429 da rate limit, dopo aver esaurito i retry dell’SDK. Mai su 400, 401, 402, 403, 413 o 422. Aggiungi un circuit breaker e verifica che il backup sia allineato al primario su funzionalità e condizioni sui dati.

## Punti chiave

-   Fai failover su errori di connessione, timeout, 5xx e 429 da rate limit, dopo un numero limitato di retry. Un 400, 401, 402, 403, 413 o 422 fallirà allo stesso modo sul provider successivo.
-   Gli ID modello cambiano da provider a provider: GLM 5.3 è \`broadnet/glm-5.3\` su BroadNet, \`zai-org/GLM-5.3\` su DeepInfra e \`accounts/fireworks/models/glm-5p3\` su Fireworks.
-   Un circuit breaker evita di pagare un timeout a ogni richiesta mentre il primario è giù.
-   Fai failover di uno stream solo prima del primo token, e non rieseguire mai una tool call che modifica qualcosa.
-   BroadNet e BroadRouter non instradano né fanno failover al posto tuo. Il self-service di BroadNet non ha impegni di disponibilità, quindi le app in produzione dovrebbero avere un fallback.

**In questa pagina**

1.  Perché tenere un provider di fallback?
2.  Quali errori devono attivare un failover?
3.  Com’è un failover in Python?
4.  Come si mappano gli ID modello tra i provider?
5.  Come mantenere risposte confrontabili dopo il cambio?
6.  E lo streaming e le tool call?
7.  Quanto costa il failover?
8.  Il fallback rispetta le stesse condizioni sui dati?
9.  Conviene usare un gateway come LiteLLM?
10.  Come testare il failover prima che serva?
11.  Dove si colloca BroadNet Inference

Ogni API LLM ha i suoi minuti storti: un 503, un timeout, una raffica di 429. Il fallback fa sì che quei minuti non diventino un disservizio nella tua app. Questo articolo mostra come fare failover tra provider [compatibili con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/) nel tuo codice: quali errori devono attivarlo, come un circuit breaker lo mantiene veloce e cosa deve combaciare tra i provider perché gli utenti non si accorgano del cambio.

Una premessa: **BroadNet Inference non instrada né fa failover tra provider al posto tuo**, e nemmeno BroadRouter. BroadRouter è il sito web di BroadNet, non un router. Il fallback lo costruisci tu, nel client come mostrato sotto oppure in un gateway come LiteLLM.

## Perché tenere un provider di fallback?

Perché la maggior parte delle API self-service non promette nulla sull’uptime. I [termini](https://www.broadnet.ai/terms) di BroadNet lo dicono chiaramente nella sezione 7.4: «self-serve has no availability commitment» (traduzione: il self-service non ha alcun impegno di disponibilità), e i livelli di servizio esistono solo in un accordo scritto separato (verifica del 15 novembre 2026). Il [confronto degli SLA delle API LLM](https://broadrouter.com/it/blog/llm-api-sla-uptime-compared/) spiega a cosa si impegnano gli altri provider. Se la tua funzionalità deve restare attiva, un secondo provider è l’assicurazione pratica, qualunque cosa dica lo SLA.

I [rate limit](https://broadrouter.com/it/glossary/rate-limit/) sono il secondo motivo. Una chiave BroadNet a consumo consente 30 richieste al minuto e 4 in parallelo. Un picco di traffico oltre quella soglia restituisce 429, e un secondo provider può assorbire l’eccesso mentre aumenti la capacità.

## Quali errori devono attivare un failover?

Dividi gli errori in due gruppi. Alcuni sono colpa del provider e altrove potrebbero andare a buon fine. Altri sono colpa tua e falliranno ovunque.

| Errore | Failover? | Perché |
| --- | --- | --- |
| Errore di connessione, timeout | Sì, dopo i retry | Il provider o la rete non sono raggiungibili |
| 500, 502, 503, 504 | Sì, dopo i retry | La documentazione di BroadNet dice di fare prima «retry with bounded exponential backoff» (traduzione: retry con backoff esponenziale limitato) |
| 429, limite di frequenza o di concorrenza | Sì, dopo il backoff | Manca capacità presso questo provider, la richiesta non è sbagliata |
| 429, limite di spesa | No | Il failover aggira il budget che hai fissato di proposito |
| 400, 422 | No | La richiesta non è valida e fallirà anche sul provider successivo |
| 401, 402 | No | Chiave, plafond o saldo. Su BroadNet un 401 copre anche un plafond a consumo esaurito, quindi il failover nasconde un problema di fatturazione |
| 403, 413 | No | Policy o dimensione; correggi la richiesta |

Il [riferimento API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-failover-fallback&utm_content=body) di BroadNet dice che un 429 significa «a rate, concurrency, token-rate or spending limit was reached» (traduzione: è stato raggiunto un limite di frequenza, di concorrenza, di token al secondo o di spesa) e consiglia di «use response details and bounded backoff» (traduzione: usare i dettagli della risposta e un backoff limitato). Leggi quei dettagli prima del failover, così un 429 per limite di spesa ferma la richiesta invece di spostarla. La [guida ai codici di errore](https://broadrouter.com/it/guides/errors-and-retries/) elenca tutti gli status.

Fai i retry prima del failover. L’SDK Python di OpenAI ritenta già errori di connessione, 408, 409, 429 e risposte 5xx «2 times by default, with a short exponential backoff» (traduzione: 2 volte di default, con un breve backoff esponenziale), e il suo timeout predefinito è di 10 minuti ([README](https://github.com/openai/openai-python), verifica del 15 novembre 2026). Dieci minuti sono decisamente troppi da aspettare prima di un failover. Imposta `timeout` per ogni client. L’[articolo sulla gestione dei 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/) spiega il backoff con jitter.

## Com’è un failover in Python?

Due client, un elenco ordinato e un piccolo circuit breaker. Il primario è GLM 5.3 su BroadNet. Il backup è lo stesso modello open-weight su DeepInfra, la cui documentazione indica la base URL `https://api.deepinfra.com/v1/openai` (verifica del 15 novembre 2026).

```python
import os
import time
from openai import (OpenAI, APIConnectionError, APITimeoutError,
                    RateLimitError, InternalServerError)

PROVIDERS = [
    {"name": "broadnet", "model": "broadnet/glm-5.3",
     "client": OpenAI(base_url="https://inference.broadnet.ai/v1",
                      api_key=os.environ["BROADNET_API_KEY"],
                      max_retries=2, timeout=60)},
    {"name": "deepinfra", "model": "zai-org/GLM-5.3",
     "client": OpenAI(base_url="https://api.deepinfra.com/v1/openai",
                      api_key=os.environ["DEEPINFRA_API_KEY"],
                      max_retries=2, timeout=60)},
]

# Provider-side failures only. 400, 401, 402, 403 and 422 raise straight through.
FAILOVER_ON = (APIConnectionError, APITimeoutError, RateLimitError, InternalServerError)
TRIP_AFTER = 3     # consecutive failures before the breaker opens
COOLDOWN = 30      # seconds to skip a provider once its breaker is open
state = {p["name"]: {"fails": 0, "open_until": 0.0} for p in PROVIDERS}

def chat(messages, **kwargs):
    last_error = None
    for p in PROVIDERS:
        s = state[p["name"]]
        if time.monotonic() < s["open_until"]:
            continue  # breaker open: don't wait on a provider that is down
        try:
            reply = p["client"].chat.completions.create(
                model=p["model"], messages=messages, **kwargs)
            s["fails"] = 0
            return p["name"], reply
        except FAILOVER_ON as err:
            last_error = err
            s["fails"] += 1
            if s["fails"] >= TRIP_AFTER:
                s["open_until"] = time.monotonic() + COOLDOWN
    raise RuntimeError("every provider failed") from last_error

served_by, reply = chat([{"role": "user", "content": "Reply with one short sentence."}],
                        max_tokens=1000)
print(served_by, reply.model, reply.choices[0].message.content)
```

Contano quattro dettagli:

1.  **Classi di eccezione.** L’SDK solleva `RateLimitError` per il 429, `InternalServerError` per 500 e superiori, e `APIConnectionError` (con `APITimeoutError` come sottoclasse) quando non riesce a connettersi. Tutto il resto resta volutamente non intercettato. Per escludere i 429 da limite di spesa, esamina `err.response` prima di proseguire.
2.  **Il circuit breaker.** Senza, ogni richiesta paga l’intero timeout su un primario morto prima di andare avanti. Dopo tre errori consecutivi il primario viene saltato per 30 secondi. Poi la richiesta successiva lo riprova.
3.  **Registra chi ha risposto.** Restituisci il nome del provider e conserva `reply.model`. Quando la qualità cambia, devi sapere quale provider ha risposto.
4.  **Budget di ragionamento.** GLM 5.3 ragiona prima di rispondere. La documentazione di BroadNet dice che il ragionamento conta in `max_tokens`, quindi lascia 1.000 o più su ogni provider.

## Come si mappano gli ID modello tra i provider?

Lo stesso modello open-weight ha un ID diverso presso ogni host, e le funzionalità dichiarate da ciascun host possono differire. GLM 5.3 al 15 novembre 2026:

|  | BroadNet Inference | DeepInfra | Fireworks AI |
| --- | --- | --- | --- |
| ID del modello | `broadnet/glm-5.3` | `zai-org/GLM-5.3` | `accounts/fireworks/models/glm-5p3` |
| Contesto | 1.048.576 token | 1.048.576 token | «1040k» token |
| Tool | Documentati | «Function» indicato | Supportati |
| Output strutturato | Documentato | «JSON» indicato | Non verificato |

Ne derivano due regole. Primo, tieni la mappatura nella configurazione, non sparsa nel codice. Secondo, scegli il fallback in base a ciò che usano le tue richieste. Su BroadNet tool e output strutturato sono documentati solo per GLM 5.3 e Qwen3.8 27B. Un agente con tool calling può passare da GLM 5.3 a GLM 5.3 altrove. Non può passare in sicurezza a un modello che non documenta i tool. Se il backup ha una finestra di contesto più piccola, accorcia il prompt o salta quel backup per le richieste lunghe. Le base URL di 14 provider sono nel [riferimento delle base URL](https://broadrouter.com/it/blog/openai-compatible-api-base-urls/).

## Come mantenere risposte confrontabili dopo il cambio?

Gli stessi pesi presso due host possono comunque rispondere in modo diverso, perché gli host possono servire precisioni, chat template o parametri predefiniti diversi. Un modello diverso risponde in modo diverso di sicuro.

-   Esegui il tuo [set di valutazione](https://broadrouter.com/it/blog/evaluate-llm-before-switching/) su ogni voce dell’elenco, non solo sul primario.
-   Fissa `temperature`, `max_tokens` e il prompt di sistema in ogni richiesta, così i default del provider non possono cambiare l’output.
-   Valida l’output strutturato allo stesso modo su ogni percorso. [Correggere JSON non valido](https://broadrouter.com/it/blog/fix-invalid-json-from-llm/) spiega il ciclo di riparazione e retry.
-   Preferisci lo stesso modello altrove a un modello diverso presso lo stesso host. Gli utenti notano un cambio di stile più di qualche secondo di latenza.

## E lo streaming e le tool call?

Uno stream può interrompersi a metà. La documentazione di BroadNet dice che uno stream che termina prima di `data: [DONE]` va trattato come incompleto: registra l’`X-Request-ID` e decidi se la tua applicazione può inviare in sicurezza una nuova richiesta.

-   **Prima del primo token:** fai failover liberamente. L’utente non ha visto nulla.
-   **Dopo che i token sono stati mostrati:** riparti sul backup e sostituisci la risposta parziale, oppure mostra un errore con un pulsante per riprovare. Cucire insieme due mezze risposte di provider diversi si legge male.
-   **Tool call con effetti collaterali:** non rieseguire mai un passaggio che invia un’email, addebita una carta o scrive in un database solo perché la chiamata al modello è fallita. Assegna a ogni azione una [chiave di idempotenza](https://broadrouter.com/it/glossary/idempotency-key/). [Agenti di lunga durata](https://broadrouter.com/it/blog/long-running-agents-timeouts-retries/) parla dei checkpoint.

[Lo streaming con SSE](https://broadrouter.com/it/blog/llm-streaming-sse-explained/) spiega come rilevare uno stream terminato in anticipo.

## Quanto costa il failover?

-   **Lavoro duplicato.** Un timeout lato tuo non prova che il provider si sia fermato. Con la fatturazione a token ogni retry è una nuova inferenza, quindi aspettati di pagare due volte alcune richieste.
-   **Prezzi diversi.** Il backup fattura alle proprie tariffe. Il 15 novembre 2026 DeepInfra indicava un prezzo promozionale per GLM-5.3, quindi ricontrolla prima di fare il budget. BroadNet applica $0.78 di input, $0.173 di input in cache e $3.46 di output per 1M di token.
-   **Cache fredde.** L’input in cache non si trasferisce tra provider. Le prime richieste sul backup pagano l’input a prezzo pieno su un prefisso che sul primario era in cache. Vedi [token di input in cache](https://broadrouter.com/it/blog/cached-input-tokens-explained/).
-   **Hedging.** Inviare ogni richiesta a due provider insieme e tenere la prima risposta riduce la latenza di coda, ma raddoppia circa la fattura. Usalo solo dove la latenza vale quel prezzo.

## Il fallback rispetta le stesse condizioni sui dati?

Un provider di fallback è un altro responsabile del trattamento che riceve gli stessi prompt. Se hai promesso qualcosa ai clienti sui loro dati, la promessa deve valere per ogni voce dell’elenco.

L’[informativa privacy](https://www.broadnet.ai/inference-privacy) di BroadNet dice: «We do not retain prompts, audio, images, answers or transcripts» (traduzione: non conserviamo prompt, audio, immagini, risposte o trascrizioni). I contenuti dell’inferenza non vengono conservati; i metadati necessari di account, fatturazione e sicurezza vengono conservati come descritto in quell’informativa. Dice anche che i dati dell’inferenza non sono usati per addestrare, fare fine-tune o valutare modelli. L’informativa dice che i modelli ospitati «run on BroadNet-owned or leased hardware in the United States, with partner capacity as backup» (traduzione: girano su hardware di proprietà di BroadNet o in leasing negli Stati Uniti, con capacità dei partner come backup); DeepSeek V4.1 Flash è ospitato da un partner. Per i dati con requisiti di residenza, i termini (sezione 7.3a) dicono di concordare i luoghi di elaborazione prima di inviarli. Verifica gli stessi punti per il backup: conservazione, uso per l’addestramento, luogo e sub-responsabili. Se non è all’altezza, tieni le richieste sensibili fuori dal percorso di fallback e falle fallire in modo chiuso. La [checklist zero data retention](https://broadrouter.com/it/blog/zero-data-retention-llm-api-checklist/) elenca le domande da fare.

## Conviene usare un gateway come LiteLLM?

Usa un gateway se più servizi hanno bisogno delle stesse regole di fallback. Il proxy di LiteLLM accetta un elenco `fallbacks` provato in ordine. `num_retries` ritenta un gruppo di modelli prima del fallback. `allowed_fails` e `cooldown_time` escludono per un po’ un deployment che fallisce, e funzionano come circuit breaker. `context_window_fallbacks` e `content_policy_fallbacks`, separati, gestiscono quei tipi di errore ([documentazione di LiteLLM](https://docs.litellm.ai/docs/proxy/reliability), verifica del 15 novembre 2026):

```yaml
model_list:
  - model_name: glm
    litellm_params:
      model: openai/broadnet/glm-5.3
      api_base: https://inference.broadnet.ai/v1
      api_key: os.environ/BROADNET_API_KEY
  - model_name: glm-backup
    litellm_params:
      model: openai/zai-org/GLM-5.3
      api_base: https://api.deepinfra.com/v1/openai
      api_key: os.environ/DEEPINFRA_API_KEY

router_settings:
  fallbacks: [{"glm": ["glm-backup"]}]
  allowed_fails: 3
  cooldown_time: 30

litellm_settings:
  num_retries: 2
  request_timeout: 60
```

La [guida al proxy LiteLLM](https://broadrouter.com/it/guides/litellm-proxy-custom-provider/) mostra la voce BroadNet completa. Entrambe le voci usano il prefisso generico `openai/` di LiteLLM con un `api_base`, lo stesso schema della guida. Un gateway aggiunge un passaggio e un componente in più da tenere in piedi. Per una singola app bastano circa 40 righe nel client, come sopra.

## Come testare il failover prima che serva?

1.  In una configurazione di test, punta il primario a un host irraggiungibile e verifica che le richieste arrivino al backup.
2.  Invia una richiesta volutamente non valida e verifica che **non** faccia failover.
3.  Usa una chiave primaria non valida e verifica che il 401 emerga come errore, non come cambio silenzioso.
4.  Osserva il breaker: dopo tre errori il primario deve essere saltato senza aspettare il timeout.
5.  Imposta un avviso quando il backup serve più di una piccola quota del traffico. Un failover silenzioso può nascondere per giorni un primario guasto.

Il `Router` di LiteLLM accetta `mock_testing_fallbacks=True` nei test diretti per forzare un fallback.

## Dove si colloca BroadNet Inference

BroadRouter è il sito web di BroadNet, e BroadNet Inference può essere l’una o l’altra voce del tuo elenco. Come primario ti dà GLM 5.3 e Qwen3.8 27B con tool e output strutturato documentati, più Gemma 4 VL 26B e DeepSeek V4.1 Flash, su un’unica [base URL](https://broadrouter.com/it/glossary/base-url/) senza conservazione dei contenuti. Come backup è un altro endpoint compatibile con OpenAI da aggiungere all’elenco. In entrambi i casi la logica di failover è tua: BroadNet non instrada tra provider e il self-service non ha SLA. Se ti servono livelli di servizio contrattuali, arrivano solo con un accordo scritto separato. Confronta i [modelli](https://broadrouter.com/it/models/), oppure [crea un account](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-failover-fallback&utm_content=body) e prova la tua catena con il credito iniziale di $5 su Gemma 4 VL 26B. GLM 5.3 e Qwen3.8 27B richiedono una ricarica.

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.

[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.

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

[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.

[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.

[Timeout della richiesta (request timeout)](https://broadrouter.com/it/glossary/request-timeout/)

Il timeout di una richiesta è il tempo massimo che un client HTTP aspetta un server prima di abbandonare la richiesta. I client di solito lo dividono in un timeout di connessione, per aprire la connessione, e un timeout di lettura, per l’attesa dei dati. Le chiamate LLM richiedono timeout di lettura generosi perché le risposte lunghe richiedono tempo.

[Limite di spesa (spend limit)](https://broadrouter.com/it/glossary/spend-limit/)

Un limite di spesa è un tetto a quanto un account, un progetto o una chiave API può spendere in un periodo, di solito un mese. Quando l’uso lo raggiunge, il provider rifiuta le richieste successive, spesso con un errore HTTP 429 o 400, finché il periodo non si azzera o il limite non viene alzato.

[Output strutturato (structured output)](https://broadrouter.com/it/glossary/structured-output/)

L’output strutturato è una funzionalità delle API LLM che vincola la risposta di un modello a un formato indicato dallo sviluppatore, di solito un JSON Schema, così il codice può interpretarla in modo affidabile. È più rigoroso della JSON mode, che garantisce un JSON valido ma non una struttura precisa.

## Domande frequenti

### Quali errori devono attivare il fallback di un’API LLM?

Errori di connessione, timeout, 5xx e 429 da rate limit, dopo i retry dell’SDK. Non fare failover su 400, 401, 402, 403, 413 o 422: è sbagliata la richiesta o l’account, e il provider successivo fallisce allo stesso modo oppure nasconde un problema di fatturazione.

### BroadNet fa failover su un altro provider in automatico?

No. BroadNet Inference non instrada le richieste tra modelli o provider, e BroadRouter, questo sito, è il sito informativo di BroadNet, non un router. Il fallback lo costruisci tu, nel client o in un gateway come LiteLLM.

### Posso usare lo stesso ID modello su tutti i provider?

No. Ogni provider chiama in modo diverso lo stesso modello open-weight. GLM 5.3 è \`broadnet/glm-5.3\` su BroadNet, \`zai-org/GLM-5.3\` su DeepInfra e \`accounts/fireworks/models/glm-5p3\` su Fireworks (verifica del 15 novembre 2026). Tieni una mappatura per provider.

### I tentativi falliti costano?

Possono costare. Un timeout lato tuo non prova che il provider abbia interrotto il lavoro, e con la fatturazione a token ogni retry è una nuova inferenza. Metti in conto qualche richiesta pagata due volte e limita i tentativi per richiesta.

### Il provider di fallback deve avere le stesse condizioni privacy?

Sì. Un fallback è un altro responsabile del trattamento che vede gli stessi prompt. Verifica le sue condizioni su conservazione, addestramento e luogo di elaborazione prima di aggiungerlo, altrimenti la tua promessa sulla privacy vale solo finché il primario è attivo.

### BroadNet ha uno SLA?

Non per il self-service. I termini di BroadNet (sezione 7.4) dicono che il self-service non ha impegni di disponibilità; i livelli di servizio esistono solo in un accordo scritto separato.

## 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/)
-   [Base URL delle API compatibili con OpenAI: 14 provider verificati](https://broadrouter.com/it/blog/openai-compatible-api-base-urls/)
-   [SLA delle API LLM: cosa promettono Azure, Bedrock, Google e OpenAI](https://broadrouter.com/it/blog/llm-api-sla-uptime-compared/)
-   [Come valutare un LLM prima di cambiare provider](https://broadrouter.com/it/blog/evaluate-llm-before-switching/)
-   [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: Instradare LiteLLM verso BroadNet Inference (SDK e proxy)](https://broadrouter.com/it/guides/litellm-proxy-custom-provider/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)

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-api-failover-fallback&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: errori e retry, limiti, streaming, funzionalità dei modelli (verifica del 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-failover-fallback&utm_content=sources)
-   [Termini di servizio di BroadNet, sezioni 7.3a (luoghi di elaborazione) e 7.4 (disponibilità) (verifica del 2026-11-15) (in inglese)](https://www.broadnet.ai/terms)
-   [Informativa privacy di BroadNet per l’inferenza: nessuna conservazione dei contenuti, nessun addestramento, hardware negli USA con backup dei partner (verifica del 2026-11-15) (in inglese)](https://www.broadnet.ai/inference-privacy)
-   [README dell’SDK Python di OpenAI: retry, timeout e classi di errore (verifica del 2026-11-15)](https://github.com/openai/openai-python)
-   [Documentazione di LiteLLM, affidabilità del proxy: fallbacks, num\_retries, allowed\_fails, cooldown\_time (verifica del 2026-11-15)](https://docs.litellm.ai/docs/proxy/reliability)
-   [Documentazione di DeepInfra, panoramica chat: base URL compatibile con OpenAI (verifica del 2026-11-15)](https://docs.deepinfra.com/chat/overview)
-   [Pagina del modello zai-org/GLM-5.3 su DeepInfra: contesto, function calling e supporto JSON (verifica del 2026-11-15)](https://deepinfra.com/zai-org/GLM-5.3)
-   [Pagina del modello GLM 5.3 su Fireworks AI: ID modello, contesto e supporto dei tool (verifica del 2026-11-15)](https://fireworks.ai/models/fireworks/glm-5p3)
