---
title: "openai-go con una base URL personalizzata (WithBaseURL)"
description: "Usa l’SDK ufficiale openai-go v3 con BroadNet Inference tramite option.WithBaseURL: chat completions, streaming con usage e gestione degli errori in Go."
url: https://broadrouter.com/it/guides/openai-go-sdk/
lang: it
updated: 2026-11-16
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/guides/openai-go-sdk/) (aggiornato il 2026-11-16).

# Chiamare BroadNet Inference da Go con l’SDK openai-go

Aggiornato 2026-11-16

Installa github.com/openai/openai-go/v3 e crea il client con option.WithBaseURL("https://inference.broadnet.ai/v1") e option.WithAPIKey con la tua chiave BroadNet. Chiama client.Chat.Completions.New con un ID di modello BroadNet, come broadnet/glm-5.3, passato come semplice stringa. Usa chat completions, non la Responses API, e imposta MaxTokens lasciando spazio al ragionamento.

`openai-go` è la libreria Go ufficiale di OpenAI. Accetta una base URL personalizzata con `option.WithBaseURL`, quindi può chiamare qualsiasi API compatibile con OpenAI. BroadNet Inference serve chat completions su `https://inference.broadnet.ai/v1`. BroadRouter è il sito di BroadNet; questa guida segue il README di openai-go per la v3.99.0.

## Installazione

```bash
go get -u 'github.com/openai/openai-go/v3@v3.99.0'
export BROADNET_API_KEY='your-broadnet-key'
```

L’attuale release richiede Go 1.26 o successivo.

## Chat completion

```go
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
)

func main() {
	client := openai.NewClient(
		option.WithBaseURL("https://inference.broadnet.ai/v1"),
		option.WithAPIKey(os.Getenv("BROADNET_API_KEY")),
	)

	resp, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
		Model: "broadnet/glm-5.3",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.SystemMessage("You are a concise Go reviewer."),
			openai.UserMessage("How do I check if a slice is empty in Go?"),
		},
		MaxTokens: openai.Int(2000), // reasoning counts toward this limit
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Choices[0].Message.Content)
}
```

Eseguilo con `go run .`. Se stampa una risposta, il test è superato: chiave, URL e ID del modello funzionano.

-   **Model** è una semplice stringa. `openai.ChatModel` è un alias di tipo per `string`, quindi gli ID di BroadNet non richiedono conversioni.
-   **Usa `Chat.Completions`.** Il README parte dalla Responses API (`client.Responses.New`), che BroadNet non elenca. La sua sezione su Chat Completions dice che quell’API è “supported indefinitely” (traduzione: supportata a tempo indeterminato).
-   **`MaxTokens` o `MaxCompletionTokens`.** L’SDK segna `max_tokens` come deprecato a favore di `max_completion_tokens`, ma il riferimento API di BroadNet descrive `max_tokens`. Usa `MaxTokens`.
-   **`SystemMessage`, non `DeveloperMessage`.** L’esempio del README usa `DeveloperMessage`, che invia il ruolo `developer`. Il riferimento API di BroadNet non menziona quel ruolo, quindi usa `system` e `user`.

## Streaming con usage

```go
stream := client.Chat.Completions.NewStreaming(context.TODO(), openai.ChatCompletionNewParams{
	Model:     "broadnet/deepseek-v4.1-flash",
	Messages:  []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Count from one to five.")},
	MaxTokens: openai.Int(2000),
	StreamOptions: openai.ChatCompletionStreamOptionsParam{
		IncludeUsage: openai.Bool(true),
	},
})
defer stream.Close()

for stream.Next() {
	chunk := stream.Current()
	if len(chunk.Choices) > 0 {
		fmt.Print(chunk.Choices[0].Delta.Content)
	}
	if chunk.Usage.TotalTokens > 0 {
		fmt.Printf("\n%d tokens\n", chunk.Usage.TotalTokens)
	}
}
if err := stream.Err(); err != nil {
	panic(err)
}
```

La documentazione di BroadNet dice che l’usage arriva nell’ultimo chunk quando `stream_options.include_usage` è true; quel chunk non ha choices, da qui il controllo sulla lunghezza. Per il formato sul filo vedi [streaming delle chat completions](https://broadrouter.com/it/guides/streaming-chat-completions/).

## Errori e nuovi tentativi

Per gli stati di errore l’SDK restituisce `*openai.Error`. Usa `errors.As` e leggi `StatusCode`:

```go
var apierr *openai.Error
if errors.As(err, &apierr) && apierr.StatusCode == 429 {
	// back off, then retry
}
```

Di default openai-go ritenta due volte alcuni errori, con un breve backoff esponenziale. Puoi cambiarlo con `option.WithMaxRetries(n)`. I nuovi tentativi contano nei limiti di frequenza di BroadNet.

## Risoluzione dei problemi

-   **401.** La chiave è sbagliata, scaduta o ha esaurito la quota. Se non hai passato `WithAPIKey`, l’SDK ha usato `OPENAI_API_KEY`.
-   **404.** La base URL deve terminare con `/v1` e la chiamata deve andare a `Chat.Completions`, non a `Responses`. Poi controlla l’ID del modello. I modelli a pagamento richiedono una ricarica; il credito di $5 copre solo `broadnet/gemma-4-26b-a4b` e i due modelli Transcribe.
-   **`Content` vuoto.** Il ragionamento ha consumato il budget di output. Alza `MaxTokens`. [Perché le risposte arrivano vuote](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **429.** Una chiave a consumo consente 30 richieste al minuto e 4 in corso. Limita le goroutine che chiamano l’API nello stesso momento. Vedi [errori e nuovi tentativi](https://broadrouter.com/it/guides/errors-and-retries/).

## Termini in questa guida

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

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

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

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

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

[API compatibile con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/)

Un’API compatibile con OpenAI è un’API HTTP che accetta gli stessi formati di richiesta e di risposta dell’API di OpenAI, come POST /v1/chat/completions, così SDK e strumenti di OpenAI possono usarla cambiando solo base URL, chiave API e nome del modello.

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

## Domande frequenti

### Posso impostare l’URL di BroadNet con le variabili d’ambiente invece che con le option?

Sì. openai-go legge di default OPENAI\_API\_KEY e OPENAI\_BASE\_URL, quindi openai.NewClient() senza option funziona se entrambe contengono i valori di BroadNet. Un option.WithBaseURL esplicito ha la precedenza su OPENAI\_BASE\_URL.

### Come passo un ID di modello BroadNet se Model si aspetta openai.ChatModel?

In openai-go ChatModel è un alias di tipo per string, quindi Model "broadnet/glm-5.3" compila così com’è.

### Perché usare SystemMessage invece di DeveloperMessage?

DeveloperMessage invia il ruolo developer, che OpenAI ha introdotto per i propri modelli. Il riferimento API di BroadNet non menziona quel ruolo, quindi il ruolo standard system è la scelta più sicura.

### Quale versione di Go mi serve?

L’attuale openai-go v3 richiede Go 1.26 o successivo. Il README dice di fissare la v3.74.0 se devi restare su Go 1.25.

## Guide correlate

-   [Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Usare l’SDK Node.js di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-node-sdk/)
-   [Streaming delle chat completions e connessioni interrotte](https://broadrouter.com/it/guides/streaming-chat-completions/)
-   [Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)
-   [Tutti gli strumenti che funzionano con BroadNet Inference (in inglese)](https://broadrouter.com/integrations/): SDK, agenti di coding, interfacce di chat e strumenti di automazione, con le impostazioni esatte per ciascuno

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-guides-openai-go-sdk&utm_content=page-cta) ·

**Fonti**

-   [README di openai-go (v3.99.0, Go 1.26+) (verificato il 2026-11-15)](https://github.com/openai/openai-go)
-   [Codice sorgente di openai-go, ChatCompletionNewParams e option.WithBaseURL (verificato il 2026-11-15)](https://github.com/openai/openai-go/blob/main/chatcompletion.go)
-   [Riferimento API di BroadNet Inference (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-guides-openai-go-sdk&utm_content=sources)
