---
title: "openai-go avec une URL de base personnalisée (WithBaseURL)"
description: "Utilisez le SDK officiel openai-go v3 avec BroadNet Inference via option.WithBaseURL : chat completions, streaming avec usage et gestion des erreurs en Go."
url: https://broadrouter.com/fr/guides/openai-go-sdk/
lang: fr
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/guides/openai-go-sdk/) (mis à jour le 2026-11-16).

# Appeler BroadNet Inference depuis Go avec le SDK openai-go

Mis à jour 2026-11-16

Installez github.com/openai/openai-go/v3 et créez le client avec option.WithBaseURL("https://inference.broadnet.ai/v1") et option.WithAPIKey défini sur votre clé BroadNet. Appelez client.Chat.Completions.New avec un ID de modèle BroadNet comme broadnet/glm-5.3, en simple chaîne. Utilisez les chat completions, pas la Responses API, et réglez MaxTokens avec de la marge pour le raisonnement.

`openai-go` est la bibliothèque Go officielle d’OpenAI. Elle accepte une URL de base personnalisée via `option.WithBaseURL` et peut donc appeler n’importe quelle API compatible OpenAI. BroadNet Inference sert les chat completions à l’adresse `https://inference.broadnet.ai/v1`. BroadRouter est le site de BroadNet ; ce guide suit le README d’openai-go pour la v3.99.0.

## Installation

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

La version actuelle nécessite Go 1.26 ou plus récent.

## 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)
}
```

Lancez-le avec `go run .`. Une réponse affichée vaut test : la clé, l’URL et l’ID du modèle fonctionnent.

-   **Model** est une simple chaîne. `openai.ChatModel` est un alias de type pour `string`, les ID BroadNet ne demandent donc aucune conversion.
-   **Utilisez `Chat.Completions`.** Le README met en avant la Responses API (`client.Responses.New`), que BroadNet ne propose pas. Sa section Chat Completions indique que cette API est « supported indefinitely » (traduction : prise en charge sans limite de durée).
-   **`MaxTokens` ou `MaxCompletionTokens`.** Le SDK marque `max_tokens` comme obsolète au profit de `max_completion_tokens`, mais la référence de l’API de BroadNet décrit `max_tokens`. Utilisez `MaxTokens`.
-   **`SystemMessage`, pas `DeveloperMessage`.** L’exemple du README utilise `DeveloperMessage`, qui envoie le rôle `developer`. La référence de l’API de BroadNet ne mentionne pas ce rôle : utilisez `system` et `user`.

## Streaming avec 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)
}
```

D’après la documentation de BroadNet, l’usage arrive dans le dernier chunk quand `stream_options.include_usage` vaut true ; ce chunk n’a pas de choices, d’où le test de longueur. Le format sur le fil est détaillé dans [streamer les chat completions](https://broadrouter.com/fr/guides/streaming-chat-completions/).

## Erreurs et nouvelles tentatives

Le SDK renvoie `*openai.Error` pour les statuts d’échec. Utilisez `errors.As` et lisez `StatusCode` :

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

Par défaut, openai-go réessaie deux fois certaines erreurs avec un court backoff exponentiel. Modifiez ce comportement avec `option.WithMaxRetries(n)`. Les nouvelles tentatives comptent dans les limites de débit de BroadNet.

## Dépannage

-   **401.** La clé est erronée, expirée ou son quota est épuisé. Si vous n’avez pas passé `WithAPIKey`, le SDK a utilisé `OPENAI_API_KEY`.
-   **404.** L’URL de base doit se terminer par `/v1`, et l’appel doit viser `Chat.Completions`, pas `Responses`. Vérifiez ensuite l’ID du modèle. Les modèles payants nécessitent une recharge ; le crédit de $5 ne couvre que `broadnet/gemma-4-26b-a4b` et les deux modèles Transcribe.
-   **`Content` vide.** Le raisonnement a consommé le budget de sortie. Augmentez `MaxTokens`. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **429.** Une clé à l’usage autorise 30 requêtes par minute et 4 requêtes en cours. Limitez le nombre de goroutines qui appellent l’API en même temps. Voir [codes d’erreur et nouvelles tentatives](https://broadrouter.com/fr/guides/errors-and-retries/).

## Termes de ce guide

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

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

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

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

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

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

[URL de base (base URL)](https://broadrouter.com/fr/glossary/base-url/)

L’URL de base est l’adresse racine fixe d’une API, comme https://api.example.com/v1, que le client place devant chaque chemin d’endpoint, comme /chat/completions. Dans les SDK compatibles OpenAI, changer l’URL de base, avec la clé d’API et l’ID du modèle, oriente le même code vers un autre fournisseur.

[Backoff exponentiel (exponential backoff)](https://broadrouter.com/fr/glossary/exponential-backoff/)

Le backoff exponentiel est une stratégie de nouvelle tentative dans laquelle un client attend plus longtemps après chaque échec, en doublant généralement le délai jusqu’à un plafond, avant de réessayer. Ajouter un jitter aléatoire à chaque attente étale les tentatives de nombreux clients, pour qu’elles ne frappent pas le serveur au même instant.

## Questions fréquentes

### Puis-je définir l’URL de BroadNet par variables d’environnement plutôt que par options ?

Oui. openai-go lit OPENAI\_API\_KEY et OPENAI\_BASE\_URL par défaut, donc openai.NewClient() sans option fonctionne si les deux contiennent les valeurs BroadNet. Un option.WithBaseURL explicite prend le pas sur OPENAI\_BASE\_URL.

### Comment passer un ID de modèle BroadNet quand Model attend un openai.ChatModel ?

Dans openai-go, ChatModel est un alias de type pour string : Model "broadnet/glm-5.3" compile tel quel.

### Pourquoi SystemMessage plutôt que DeveloperMessage ?

DeveloperMessage envoie le rôle developer, qu’OpenAI a introduit pour ses propres modèles. La référence de l’API de BroadNet ne mentionne pas ce rôle : le rôle system standard est le choix le plus sûr.

### Quelle version de Go faut-il ?

L’openai-go v3 actuel nécessite Go 1.26 ou plus récent. Son README conseille d’épingler v3.74.0 si vous devez rester sur Go 1.25.

## Guides associés

-   [Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Utiliser le SDK Node.js d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-node-sdk/)
-   [Streamer des chat completions et gérer les connexions coupées](https://broadrouter.com/fr/guides/streaming-chat-completions/)
-   [Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [Tous les outils compatibles avec BroadNet Inference (en anglais)](https://broadrouter.com/integrations/) : SDK, agents de code, interfaces de chat et outils d’automatisation, avec les réglages exacts pour chacun

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-openai-go-sdk&utm_content=page-cta) ·

**Sources**

-   [README d’openai-go (v3.99.0, Go 1.26+) (consulté le 2026-11-15)](https://github.com/openai/openai-go)
-   [Code source d’openai-go, ChatCompletionNewParams et option.WithBaseURL (consulté le 2026-11-15)](https://github.com/openai/openai-go/blob/main/chatcompletion.go)
-   [Référence de l’API de BroadNet Inference (consultée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-openai-go-sdk&utm_content=sources)
