---
title: "openai-go com base URL personalizada (WithBaseURL) | BroadRouter"
description: "Use o SDK oficial openai-go v3 com a BroadNet Inference via option.WithBaseURL: chat completions, streaming com usage e tratamento de erros em Go."
url: https://broadrouter.com/pt/guides/openai-go-sdk/
lang: pt-BR
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/guides/openai-go-sdk/) (atualizado em 2026-11-16).

# Chamar a BroadNet Inference em Go com o SDK openai-go

Atualizado em 2026-11-16

Instale github.com/openai/openai-go/v3 e crie o cliente com option.WithBaseURL("https://inference.broadnet.ai/v1") e option.WithAPIKey com a sua chave da BroadNet. Chame client.Chat.Completions.New com um ID de modelo da BroadNet, como broadnet/glm-5.3, passado como string simples. Use chat completions, não a Responses API, e defina MaxTokens com folga para o raciocínio.

`openai-go` é a biblioteca Go oficial da OpenAI. Ela aceita uma base URL personalizada com `option.WithBaseURL`, então pode chamar qualquer API compatível com a OpenAI. A BroadNet Inference serve chat completions em `https://inference.broadnet.ai/v1`. O BroadRouter é o site da própria BroadNet; este guia segue o README do openai-go para a v3.99.0.

## Instalação

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

A versão atual exige Go 1.26 ou mais recente.

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

Rode com `go run .`. Se aparecer uma resposta, o teste passou: chave, URL e ID do modelo funcionam.

-   **Model** é uma string simples. `openai.ChatModel` é um alias de tipo para `string`, então os IDs da BroadNet não precisam de conversão.
-   **Use `Chat.Completions`.** O README começa pela Responses API (`client.Responses.New`), que a BroadNet não lista. A seção de Chat Completions diz que essa API é “supported indefinitely” (tradução: suportada por tempo indeterminado).
-   **`MaxTokens` ou `MaxCompletionTokens`.** O SDK marca `max_tokens` como obsoleto em favor de `max_completion_tokens`, mas a referência da API da BroadNet descreve `max_tokens`. Use `MaxTokens`.
-   **`SystemMessage`, não `DeveloperMessage`.** O exemplo do README usa `DeveloperMessage`, que envia o papel `developer`. A referência da API da BroadNet não menciona esse papel, então use `system` e `user`.

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

A documentação da BroadNet diz que o usage chega no último chunk quando `stream_options.include_usage` é true; esse chunk não tem choices, daí a verificação do tamanho. Para o formato no fio, veja [streaming de chat completions](https://broadrouter.com/pt/guides/streaming-chat-completions/).

## Erros e novas tentativas

Para status de erro, o SDK retorna `*openai.Error`. Use `errors.As` e leia `StatusCode`:

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

Por padrão, o openai-go tenta de novo alguns erros duas vezes, com um backoff exponencial curto. Mude isso com `option.WithMaxRetries(n)`. As novas tentativas contam nos limites de taxa da BroadNet.

## Solução de problemas

-   **401.** A chave está errada, expirou ou ficou sem cota. Se você não passou `WithAPIKey`, o SDK usou `OPENAI_API_KEY`.
-   **404.** A base URL precisa terminar em `/v1`, e a chamada precisa ir para `Chat.Completions`, não para `Responses`. Depois confira o ID do modelo. Os modelos pagos exigem uma recarga; o crédito de $5 cobre só `broadnet/gemma-4-26b-a4b` e os dois modelos Transcribe.
-   **`Content` vazio.** O raciocínio gastou o orçamento de saída. Aumente `MaxTokens`. [Por que as respostas voltam vazias](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **429.** Uma chave de pagamento por uso permite 30 requisições por minuto e 4 em andamento. Limite as goroutines que chamam a API ao mesmo tempo. Veja [erros e novas tentativas](https://broadrouter.com/pt/guides/errors-and-retries/).

## Termos neste guia

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

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

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

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

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

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Rate limit (limite de taxa)](https://broadrouter.com/pt/glossary/rate-limit/)

Um rate limit é um teto que uma API impõe a quanto um cliente pode usá-la em um intervalo de tempo, como requisições por minuto ou tokens por minuto. As requisições acima do limite são recusadas, normalmente com HTTP 429 Too Many Requests, até que o uso volte a ficar abaixo dele.

[API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/)

Uma API compatível com a OpenAI é uma API HTTP que aceita os mesmos formatos de requisição e de resposta da API da OpenAI, como POST /v1/chat/completions, de modo que SDKs e ferramentas da OpenAI podem usá-la trocando só a base URL, a chave de API e o nome do modelo.

[Backoff exponencial (exponential backoff)](https://broadrouter.com/pt/glossary/exponential-backoff/)

Backoff exponencial é uma estratégia de retry em que o cliente espera mais tempo depois de cada tentativa que falha, normalmente dobrando o atraso até um teto, antes de tentar de novo. Adicionar um jitter aleatório a cada espera espalha os retries de muitos clientes, para que não atinjam o servidor no mesmo instante.

## Perguntas frequentes

### Posso definir a URL da BroadNet com variáveis de ambiente em vez de options?

Sim. O openai-go lê OPENAI\_API\_KEY e OPENAI\_BASE\_URL por padrão, então openai.NewClient() sem options funciona se as duas tiverem os valores da BroadNet. Um option.WithBaseURL explícito tem prioridade sobre OPENAI\_BASE\_URL.

### Como passo um ID de modelo da BroadNet se Model espera openai.ChatModel?

No openai-go, ChatModel é um alias de tipo para string, então Model "broadnet/glm-5.3" compila do jeito que está.

### Por que usar SystemMessage e não DeveloperMessage?

DeveloperMessage envia o papel developer, que a OpenAI criou para os próprios modelos. A referência da API da BroadNet não menciona esse papel, então o papel padrão system é a escolha mais segura.

### Qual versão do Go eu preciso?

O openai-go v3 atual exige Go 1.26 ou mais recente. O README diz para fixar a v3.74.0 se você precisar continuar no Go 1.25.

## Guias relacionados

-   [Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Como usar o SDK Node.js da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-node-sdk/)
-   [Streaming de chat completions e conexões que caem](https://broadrouter.com/pt/guides/streaming-chat-completions/)
-   [Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)
-   [Todas as ferramentas que funcionam com a BroadNet Inference (em inglês)](https://broadrouter.com/integrations/): SDKs, agentes de programação, interfaces de chat e ferramentas de automação, com as configurações exatas de cada uma

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

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

**Fontes**

-   [README do openai-go (v3.99.0, Go 1.26+) (conferido em 2026-11-15)](https://github.com/openai/openai-go)
-   [Código-fonte do openai-go, ChatCompletionNewParams e option.WithBaseURL (conferido em 2026-11-15)](https://github.com/openai/openai-go/blob/main/chatcompletion.go)
-   [Referência da API da BroadNet Inference (conferido em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-guides-openai-go-sdk&utm_content=sources)
