go-openai

# Go OpenAI

[![Go Reference](https://pkg.go.dev/badge/github.com/sashabaranov/go-openai.svg)](https://pkg.go.dev/github.com/sashabaranov/go-openai)
[![codecov](https://codecov.io/gh/sashabaranov/go-openai/branch/master/graph/badge.svg?token=bCbIfHLIsW)](https://codecov.io/gh/sashabaranov/go-openai)

An unofficial Go client for the [OpenAI API](https://developers.openai.com/api/docs/overview).

For new text-generation, reasoning, tool-calling, and multi-turn integrations,
start with the [Responses API](https://developers.openai.com/api/docs/guides/migrate-to-responses).
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.

**Building agents?** Try [Unreal Agent](https://github.com/unreallabsai/unreal-agent) - Go-based, fully async harness that drives 40% cost savings compared to Codex!

## Installation

```sh
go get github.com/sashabaranov/go-openai
```

Go OpenAI requires Go 1.18 or later.

## Quick start: Responses API

Set an [OpenAI API key](https://platform.openai.com/api-keys) in your environment:

```sh
export OPENAI_API_KEY="<your key>"
```

Then create a response and read its generated text:

```go
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.

```go
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

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