go-openai README

The project's README from github.com/sashabaranov/go-openai. As one markdown file: README.md.

Go OpenAI

Go Reference codecov

An unofficial Go client for the OpenAI API.

For new text-generation, reasoning, tool-calling, and multi-turn integrations, start with the Responses API. Chat Completions remains available for existing integrations.

The client also covers embeddings, images, audio, moderation, files, fine-tuning, batches, vector stores, and legacy Assistants API surfaces.

Installation

go get github.com/sashabaranov/go-openai

Go OpenAI requires Go 1.18 or later.

Quick start: Responses API

Set an OpenAI API key in your environment:

export OPENAI_API_KEY="<your key>"

Then create a response and read its generated text:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	client := openai.NewClient(os.Getenv("OPENAI_API_KEY"))

	response, err := client.CreateResponse(context.Background(), openai.CreateResponseRequest{
		Model:        openai.GPT5Dot6Sol,
		Instructions: "You are a concise technical explainer.",
		Input:        "Why is the sky blue?",
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(response.GetOutputText())
}

Input can be a string or a slice of typed input items. For reasoning, tools, multimodal output, or custom processing, inspect response.Output instead of using the GetOutputText convenience method.

Continue a conversation

Use PreviousResponseID when OpenAI should carry the earlier response context. Resend Instructions on each call when they should continue to apply.

store := true

first, err := client.CreateResponse(ctx, openai.CreateResponseRequest{
	Model:        openai.GPT5Dot6Sol,
	Instructions: "Answer as a travel guide.",
	Input:        "What should I see in Lisbon?",
	Store:        &store,
})
if err != nil {
	return err
}

second, err := client.CreateResponse(ctx, openai.CreateResponseRequest{
	Model:              openai.GPT5Dot6Sol,
	Instructions:       "Answer as a travel guide.",
	Input:              "Which one is best on a rainy day?",
	PreviousResponseID: first.ID,
	Store:              &store,
})
if err != nil {
	return err
}

fmt.Println(second.GetOutputText())

Stream output

stream, err := client.CreateResponseStream(ctx, openai.CreateResponseRequest{
	Model: openai.GPT5Dot6Sol,
	Input: "Write a short story about a curious gopher.",
})
if err != nil {
	return err
}
defer stream.Close()

for {
	event, err := stream.Recv()
	if errors.Is(err, io.EOF) {
		break
	}
	if err != nil {
		return err
	}
	if event.Type == openai.ResponseStreamEventOutputTextDelta {
		fmt.Print(event.Delta)
	}
}

Choosing a model

The current GPT-5.6 family exposes separate capability, balance, and efficiency tiers. Pick the tier that matches the workload instead of using the flagship for every request.

Constant Model ID Typical use
GPT5Dot6Sol gpt-5.6-sol Complex reasoning and coding
GPT5Dot6Terra gpt-5.6-terra Balance of intelligence and cost
GPT5Dot6Luna gpt-5.6-luna Cost-sensitive, high-volume work
GPT5Dot6 gpt-5.6 Family alias that currently routes to Sol

See the OpenAI model catalog for capabilities and availability. Model IDs are accepted as strings, so you can use a model before a named constant is added to this package.

Chat Completions

Chat Completions remains supported for existing integrations:

response, err := client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
	Model: openai.GPT4oMini,
	Messages: []openai.ChatCompletionMessage{
		{
			Role:    openai.ChatMessageRoleUser,
			Content: "Hello!",
		},
	},
})
if err != nil {
	return err
}

fmt.Println(response.Choices[0].Message.Content)

For a new integration, prefer Responses unless you specifically need the Chat Completions request or response shape.

Configuration

Use DefaultConfig to customize the HTTP client, base URL, organization, or headers before constructing a client:

config := openai.DefaultConfig(os.Getenv("OPENAI_API_KEY"))
config.BaseURL = "https://your-compatible-endpoint.example/v1"
client := openai.NewClientWithConfig(config)

For Azure OpenAI, start with DefaultAzureConfig and configure the deployment mapping or API version required by your Azure resource.

Error handling

API failures can be inspected with errors.As:

var apiError *openai.APIError
if errors.As(err, &apiError) {
	fmt.Printf("OpenAI error: status=%d code=%v message=%s\n",
		apiError.HTTPStatusCode, apiError.Code, apiError.Message)
}

Examples

Runnable examples live in examples/:

To run one:

go run ./examples/responses

Contributing

See the contributing guidelines before opening a pull request.

Thank you

Thank you to all of the project's contributors and sponsors, including Carson Kahn of Spindle AI.

go-openai (sashabaranov/go-openai)

Searching Database…

10.8K ·GitHub
Go-openai
What is this?go-openai is an unofficial Go client library for the OpenAI API, giving Go developers typed access to text generation, chat, images, audio, embeddings, moderation, fine-tuning, batches and vector stores.
Is this a framework or just a library I import?It is a plain Go library you import with go get; there's no CLI or server component, just typed API clients covering embeddings, images, audio, moderation, files, fine-tuning, batches, vector stores and the legacy Assistants API.
How do I add it to my Go project?Run go get to pull the package, set your OpenAI API key as an environment variable, then call the Responses API to create and read a response.
Do I need an OpenAI API key, and does it pull in other libraries?You need your own OpenAI API key set as an environment variable; the package itself is zero-dependency, so it doesn't drag in extra third-party packages.
Should I use Chat Completions or the newer Responses API?For new text-generation, reasoning, tool-calling, or multi-turn integrations you should start with the Responses API; Chat Completions is kept around mainly for existing integrations that already depend on its shape.
What's the difference between the Responses API and Chat Completions in this client?Responses API is the recommended path for new text-generation, reasoning, tool-calling and multi-turn work and lets you inspect response.Output for multimodal results, while Chat Completions is mainly kept for integrations that already rely on its request/response shape.
Can I point this client at Azure OpenAI instead of OpenAI directly?Yes, you start with DefaultAzureConfig and configure the deployment mapping or API version required by your Azure resource.
Does the client support streaming output?Yes, the Responses API supports streaming so you can read generated text as it arrives rather than waiting for the full response.
What non-chat capabilities does the library expose?Beyond chat and the Responses API it covers embeddings, image generation, speech-to-text audio, moderation, file uploads, fine-tuning jobs, batches, and vector stores.
What are similar projects?gpt4free, vault-ai, generative-ai-for-beginners, wechat-chatgpt, Hello-Python, ollama-python, h2ogpt, unsloth
Which topics is it in?chatgpt-api, http-client, openai-api, speech-to-text, embeddings, fine-tuning, chatgpt, image-generation, golang, streaming, sdk, openai
Creator
sashabaranov
Size
0.9 MB
Stars
10.8K
Updated
CommitSep 29Releasev1.43.0Sep 29
Age
6y
Commits · 90 Days