---
title: "Migrare dall’API di OpenAI: diff del codice e test | BroadRouter"
description: "Le modifiche al codice per passare da OpenAI a un’API compatibile: client, da Responses a Chat Completions, strumenti, streaming, embedding e uno smoke test."
url: https://broadrouter.com/it/blog/migrate-from-openai-api-code-walkthrough/
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/migrate-from-openai-api-code-walkthrough/) (aggiornato il 2026-11-15).

# Migrare dall’API di OpenAI: il codice in Python, Node e cURL

A cura del team di BroadNet Inference · 6 min di lettura · Pubblicato 2026-11-15

Cambia base URL, chiave API e ID del modello del client. Per le chiamate Chat Completions basta questo. Il codice sulla Responses API va riscritto per Chat Completions: input diventa messages, output\_text diventa choices\[0\].message.content e gli strumenti perdono un livello di annidamento. Tieni gli embedding su un client separato se il nuovo provider non li offre, poi esegui uno smoke test prima di spostare il traffico.

## Punti chiave

-   Per il codice Chat Completions, il cambio riguarda tre valori: base\_url, api\_key e model. Entrambi gli SDK ufficiali leggono anche OPENAI\_BASE\_URL e OPENAI\_API\_KEY dall’ambiente.
-   Impostare OPENAI\_BASE\_URL sposta tutte le chiamate, embedding compresi. Se il nuovo provider non ha un endpoint per gli embedding, dai agli embedding un client dedicato.
-   Il codice sulla Responses API va riscritto: da input a messages, da instructions a un messaggio di sistema, da text.format a response\_format, e da definizioni degli strumenti piatte ad annidate.
-   BroadNet Inference documenta /v1/chat/completions, /v1/audio/transcriptions e GET /v1/models, e nessun endpoint per embedding, file o batch. La sua documentazione indica strumenti e output strutturato per GLM 5.3 e Qwen3.8 27B.
-   Prova prima di cambiare: chat semplice, usage in streaming, un budget di ragionamento e una chiave errata, più una chiamata a uno strumento se usi gli strumenti.

**In questa pagina**

1.  Che cosa cambia nella configurazione del client?
2.  E se il mio codice usa la Responses API?
3.  Come cambiano le chiamate agli strumenti?
4.  E l’output strutturato?
5.  Che cosa succede agli embedding?
6.  Come cambia il codice di streaming?
7.  Cambiano la gestione degli errori e i retry?
8.  Quali parametri si comportano diversamente?
9.  Come si prova il cambio?
10.  Che cosa si rompe più spesso?
11.  Dove si colloca BroadNet Inference

Spostare un’app da OpenAI a un provider compatibile con OpenAI è una piccola modifica al codice se usi Chat Completions, e una riscrittura se usi la Responses API. Questo articolo mostra le diff esatte in Python, Node e cURL, cosa fare con Responses, strumenti, output strutturato ed embedding, e uno smoke test da eseguire prima di spostare il traffico. Gli esempi usano BroadNet Inference su `https://inference.broadnet.ai/v1`; gli stessi passaggi valgono per qualsiasi provider.

Questo è il complemento in codice della [checklist per la migrazione](https://broadrouter.com/it/blog/openai-compatible-api-migration-checklist/), che tratta rate limit, errori e pianificazione del passaggio. Per le base URL degli altri provider, vedi [le base URL compatibili con OpenAI, verificate](https://broadrouter.com/it/blog/openai-compatible-api-base-urls/).

## Che cosa cambia nella configurazione del client?

Tre valori: base URL, chiave API e ID del modello.

**Python**

```python
import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
```

**Node**

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
```

**cURL**

```bash
curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
```

Fai attenzione al percorso: la base URL finisce già con `/v1`, quindi l’SDK aggiunge `/chat/completions`. Raddoppiare `/v1` è il primo errore più comune.

### Posso cambiare senza toccare il codice?

Sì, per il codice Chat Completions. L’SDK Python legge `OPENAI_BASE_URL` quando non passi `base_url`, e il client Node usa come valore predefinito di `baseURL` `process.env['OPENAI_BASE_URL']`. Entrambi leggono `OPENAI_API_KEY`. Impostando due variabili d’ambiente sposti tutte le chiamate.

Ed è proprio questo il rischio. Si sposta **ogni chiamata**, compresi embedding, moderazione, upload di file e qualsiasi altra cosa che il nuovo provider potrebbe non avere. Usa il cambio tramite variabili d’ambiente solo quando la tua app fa chiamate di chat e nient’altro.

## E se il mio codice usa la Responses API?

I README degli SDK di OpenAI ora definiscono la Responses API come l’API principale; il README Python chiama Chat Completions “the previous standard (supported indefinitely)” (traduzione: lo standard precedente, supportato a tempo indeterminato). Molti provider compatibili implementano solo Chat Completions. BroadNet documenta `POST /v1/chat/completions` e `POST /v1/audio/transcriptions`, quindi le chiamate Responses vanno riscritte. La corrispondenza:

| Responses API | Chat Completions |
| --- | --- |
| `client.responses.create(...)` | `client.chat.completions.create(...)` |
| `instructions="..."` | Primo messaggio `{"role": "system", "content": "..."}` |
| `input="..."` o un elenco di elementi | `messages=[...]` |
| `response.output_text` | `response.choices[0].message.content` |
| `max_output_tokens` | `max_tokens` (documentazione di BroadNet) o `max_completion_tokens` |
| `text={"format": {...}}` | `response_format={...}` |
| `previous_response_id`, conversazioni | Reinvia tu l’intera cronologia dei messaggi |
| Strumento `{"type": "function", "name": ...}` | Strumento `{"type": "function", "function": {"name": ...}}` |
| Elemento di output `function_call`, risposta con `function_call_output` e `call_id` | `message.tool_calls`, risposta con ruolo `tool` e `tool_call_id` |
| Strumenti integrati (ricerca web, ricerca nei file) | Non disponibili; usa un tuo strumento |

Il prima e il dopo di una chiamata semplice:

```python
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
```

Il cambiamento strutturale più grande è lo stato. Responses può mantenere lo stato della conversazione lato OpenAI con `previous_response_id`. Chat Completions non ha stato lato server, quindi è il tuo codice a salvare l’elenco dei messaggi e a inviarlo per intero a ogni turno. Mettilo in conto: l’intera cronologia diventa token di input a ogni chiamata.

## Come cambiano le chiamate agli strumenti?

In Chat Completions, la definizione di uno strumento annida la funzione sotto una chiave `function`, e la risposta torna come messaggio `tool`:

```python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
```

Il modello conta più della forma. La documentazione di BroadNet indica gli strumenti solo per [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) e [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/). Non puntare un loop di strumenti su un modello la cui documentazione non li elenca, e valida gli argomenti prima di eseguire qualsiasi cosa. [Tool calling con i modelli open](https://broadrouter.com/it/blog/tool-calling-open-models/) contiene un loop completo con validazione.

## E l’output strutturato?

`client.chat.completions.parse(..., response_format=MyPydanticModel)` e `zodResponseFormat` in Node inviano entrambi `response_format` con uno schema JSON. Funzionano solo se il provider accetta quella forma su quel modello. BroadNet indica l’output strutturato per GLM 5.3 e Qwen3.8 27B ma non specifica il parametro della richiesta. Esegui il test in quattro passi di [JSON mode o json\_schema](https://broadrouter.com/it/blog/structured-output-json-schema/) una volta per modello, e continua a validare il risultato del parsing, qualunque cosa prometta il provider.

## Che cosa succede agli embedding?

Se cambi la base URL su un client condiviso e il provider non ha un endpoint per gli embedding, ogni chiamata `client.embeddings.create` fallisce. BroadNet non vende [embedding](https://broadrouter.com/it/glossary/embeddings/). Tieni due client:

```python
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
```

Non mescolare mai in uno stesso indice vettori di due modelli di embedding diversi. Se cambi anche provider di embedding, ricalcola gli embedding dell’intero corpus. Il [calcolatore dei costi degli embedding](https://broadrouter.com/tools/embedding-cost-calculator/) ti dice quanto costa.

Lo stesso vale per tutto ciò che non è chat: generazione di immagini, text-to-speech, moderazione, Batch API e archiviazione di file. BroadNet non offre nessuno di questi. Lo speech-to-text invece si sposta: `client.audio.transcriptions.create` funziona su `/v1/audio/transcriptions` con WAV o MP3 e un campo `language` ([guida allo speech-to-text in arabo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/)).

## Come cambia il codice di streaming?

La Responses API trasmette eventi tipizzati, come `response.output_text.delta` e `response.completed`. Chat Completions trasmette chunk, e il testo si trova in `choices[0].delta.content`. L’usage non viene inviato se non lo chiedi, e in quel caso arriva in un chunk finale con un elenco `choices` vuoto.

```javascript
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}
```

Due abitudini rendono sicuro il codice di streaming dopo il cambio. Proteggi l’accesso a `choices[0]`, perché il chunk con l’usage non ha choices. E considera incompleto uno stream che termina prima della riga finale `data: [DONE]`; la documentazione di BroadNet dice di registrare l’`X-Request-ID` e decidere se una nuova richiesta è sicura. [Streaming delle chat completions](https://broadrouter.com/it/guides/streaming-chat-completions/) mostra lo schema completo in Python.

## Cambiano la gestione degli errori e i retry?

Le classi di errore dell’SDK restano le stesse: `AuthenticationError` per il 401, `RateLimitError` per il 429, `APIStatusError` per il resto. Cambia il significato di ogni stato presso il nuovo provider. Su BroadNet, un 401 può indicare un plafond a consumo esaurito, non solo una chiave sbagliata, e un 402 indica saldo insufficiente per un acquisto. Nessuno dei due si risolve con un retry. Un 429 può venire dal limite di frequenza, di concorrenza, di token al minuto o di spesa. Ritenta 429 e 5xx con backoff, e correggi tutto il resto. La [guida a errori e retry](https://broadrouter.com/it/guides/errors-and-retries/) contiene la tabella completa.

L’SDK ritenta per impostazione predefinita errori di connessione, 408, 409, 429 e 5xx due volte. Se aggiungi un tuo loop di retry, imposta `max_retries=0` sul client, così i due non si sommano.

## Quali parametri si comportano diversamente?

| Parametro | Che cosa verificare |
| --- | --- |
| `max_tokens` / `max_completion_tokens` | OpenAI depreca `max_tokens`; la documentazione di BroadNet lo usa. Sui modelli di ragionamento include il ragionamento, quindi valori bassi restituiscono risposte vuote ([perché](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)) |
| `reasoning_effort` | BroadNet documenta `low`; prova gli altri valori prima di farci affidamento |
| `stream_options: {"include_usage": true}` | Documentato da BroadNet; l’usage arriva nell’ultimo chunk |
| `n`, `logprobs`, `seed`, `logit_bias` | Non presenti nella documentazione di BroadNet; provali o rimuovili |
| `store`, `metadata` | Funzionalità di archiviazione di OpenAI; eliminali |
| Parti di contenuto `image_url` | Solo sui modelli indicati con supporto alle immagini: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |

## Come si prova il cambio?

Esegui un breve smoke test sul nuovo provider prima di spostare qualsiasi traffico. Questo verifica chat semplice, usage in streaming, budget di ragionamento e autenticazione. Aggiungi un caso con chiamata a uno strumento se usi gli strumenti.

```python
import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")
```

Poi confronta la qualità, non solo la forma. Riesegui un campione di prompt reali su entrambi i provider e valuta le risposte; [valutare un LLM prima di cambiarlo](https://broadrouter.com/it/blog/evaluate-llm-before-switching/) spiega come. Lo [strumento di migrazione da OpenAI a BroadNet](https://broadrouter.com/tools/openai-to-broadnet-migration/) ti aiuta a riscrivere uno snippet ed elenca le funzionalità che usa.

## Che cosa si rompe più spesso?

-   **Una base URL globale** che sposta anche gli embedding e le chiamate ai file.
-   **Helper esclusivi di Responses** come `output_text`, rimasti in codice che ora chiama Chat Completions.
-   **ID dei modelli.** I nomi `gpt-...` non esistono altrove. Su BroadNet hanno una forma come `broadnet/glm-5.3`.
-   **Risposte vuote** dai modelli di ragionamento con un `max_tokens` basso.
-   **Rate limit.** Una chiave BroadNet a consumo consente 30 richieste al minuto e 4 in corso. I job massivi hanno bisogno di una coda ([gestione dei 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/)).

## Dove si colloca BroadNet Inference

BroadNet Inference è adatto alle app che usano OpenAI per chat e trascrizione: assistenti, estrazione, riassunti, traduzione e voce in arabo. È adatto anche alle app che vogliono piani flat di [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) per gli agenti. È la destinazione sbagliata se dipendi dallo stato lato server della Responses API, dagli strumenti integrati, dagli embedding, dalla generazione di immagini, dal text-to-speech, dalla voce in tempo reale o dalla Batch API. Sposta queste funzioni su provider che le offrono, oppure lasciale su OpenAI e sposta solo le chiamate di chat. Gemma 4 VL 26B ed entrambi i modelli di trascrizione funzionano con il credito iniziale di $5; GLM 5.3, Qwen3.8 27B e DeepSeek V4.1 Flash richiedono prima 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

[Embedding (embeddings)](https://broadrouter.com/it/glossary/embeddings/)

Gli embedding sono liste di numeri in virgola mobile (vettori) che un modello produce per rappresentare un testo, un’immagine o un altro input. Input con significato simile ottengono vettori vicini tra loro, quindi la distanza tra vettori serve a ordinare i risultati di ricerca, raggruppare documenti o trovare elementi correlati.

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

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

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

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

[Streaming](https://broadrouter.com/it/glossary/streaming/)

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

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

[Speech-to-text (riconoscimento vocale)](https://broadrouter.com/it/glossary/speech-to-text/)

Lo speech-to-text, detto anche riconoscimento automatico del parlato (ASR), è la tecnologia che converte l’audio parlato in testo scritto. Un’API speech-to-text riceve un file o uno stream audio e restituisce una trascrizione, di solito a prezzo per minuto di audio. L’accuratezza si misura con il word error rate e varia con accento, dialetto e qualità della registrazione.

## Domande frequenti

### Mi serve un SDK diverso per usare un’API compatibile con OpenAI?

No. Tieni il pacchetto ufficiale openai e passa una base\_url diversa (Python) o baseURL (Node), più la chiave del nuovo provider. Gli oggetti di richiesta e risposta restano gli stessi per gli endpoint che il provider supporta.

### Un’API compatibile con OpenAI supporta la Responses API?

Alcune sì; molte supportano solo Chat Completions. Controlla l’elenco degli endpoint del provider. BroadNet Inference documenta /v1/chat/completions e /v1/audio/transcriptions, quindi il codice Responses va riscritto per Chat Completions.

### Che fine fanno i miei embedding quando cambio provider?

Si rompono se il nuovo provider non ha un endpoint per gli embedding e hai cambiato la base URL a livello globale. BroadNet non vende embedding, quindi tieni un client per gli embedding puntato sul tuo provider di embedding. Non mescolare mai in uno stesso indice vettori di due modelli di embedding diversi.

### Devo inviare max\_tokens o max\_completion\_tokens?

OpenAI indica max\_tokens come deprecato a favore di max\_completion\_tokens. Molti provider compatibili documentano invece max\_tokens, e la documentazione di BroadNet usa max\_tokens. Invia quello che il provider documenta e verifica nello smoke test che il limite venga applicato.

### Gli helper di OpenAI per l’output strutturato funzioneranno ancora?

Solo se il provider accetta response\_format con json\_schema sul modello che usi. BroadNet indica l’output strutturato per GLM 5.3 e Qwen3.8 27B ma non specifica il parametro della richiesta, quindi provalo, e continua a validare il risultato del parsing.

## Continua a leggere

-   [Passare a un’API compatibile con OpenAI: la checklist di migrazione](https://broadrouter.com/it/blog/openai-compatible-api-migration-checklist/)
-   [Base URL delle API compatibili con OpenAI: 14 provider verificati](https://broadrouter.com/it/blog/openai-compatible-api-base-urls/)
-   [Tool calling con modelli aperti: schemi, chiamate parallele, retry](https://broadrouter.com/it/blog/tool-calling-open-models/)
-   [JSON mode o json\_schema: output strutturato che regge in produzione](https://broadrouter.com/it/blog/structured-output-json-schema/)
-   [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: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Usare l’SDK Node.js di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-node-sdk/)
-   [Guida: Prima richiesta a BroadNet Inference con curl](https://broadrouter.com/it/guides/curl-quickstart/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)

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-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: endpoint, ID dei modelli, funzionalità, usage in streaming, errori (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [README di openai-python: Responses è l’API principale, Chat Completions supportata a tempo indeterminato, retry (verificato il 2026-11-15)](https://github.com/openai/openai-python)
-   [Sorgente del client openai-node: baseURL ha come valore predefinito OPENAI\_BASE\_URL (verificato il 2026-11-15)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, migrare alla Responses API: differenze su output strutturato, strumenti e archiviazione (verificato il 2026-11-15)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [Guida di OpenAI al function calling: forma degli strumenti in entrambe le API (verificato il 2026-11-15)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Riferimento di OpenAI per Chat Completions: max\_tokens deprecato a favore di max\_completion\_tokens (verificato il 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
