UI Kit Demo

DocsTip

Use DocsTip for helpful callouts inside guides or references.

DocCardGroup

API reference

Browse endpoints, parameters, and responses.

Resources

Find guides, best practices, and examples.

Local anchor

Jump to a section on the page.

Markdown

Use Markdown content here to validate styles and link handling.

Bullet one
Bullet two

Internal link and external link.

ContentModeSwitch

Responses sample

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY"

CodeSample

Examples

JavaScript

1
2
3
4
5
6
7
8import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-4.1-mini",
  input: "Say hello",
});

1
2
3
4
5
6
7
8from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-mini",
    input="Say hello",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import (
	"context"
	"fmt"
	"log"

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

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-4.1-mini", Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say hello")},
	})
	if err != nil {
		return err
	}
	fmt.Println(response.OutputText())
	return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder().model("gpt-4.1-mini").input("Say hello").build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-4.1-mini",
    "Say hello"
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5require "openai"

client = OpenAI::Client.new
response = client.responses.create(model: "gpt-4.1-mini", input: "Say hello")
puts(response.output_text)

Examples

JavaScript

1
2
3
4
5
6
7
8import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-4.1-mini",
  input: "Say hello",
});

1
2
3
4
5
6
7
8from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-mini",
    input="Say hello",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import (
	"context"
	"fmt"
	"log"

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

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-4.1-mini", Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say hello")},
	})
	if err != nil {
		return err
	}
	fmt.Println(response.OutputText())
	return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder().model("gpt-4.1-mini").input("Say hello").build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-4.1-mini",
    "Say hello"
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5require "openai"

client = OpenAI::Client.new
response = client.responses.create(model: "gpt-4.1-mini", input: "Say hello")
puts(response.output_text)

hello

CodeSample

Examples

JavaScript

1
2
3
4
5
6
7
8import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-4.1-mini",
  input: "Say hello",
});

1
2
3
4
5
6
7
8from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-mini",
    input="Say hello",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import (
	"context"
	"fmt"
	"log"

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

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-4.1-mini", Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say hello")},
	})
	if err != nil {
		return err
	}
	fmt.Println(response.OutputText())
	return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder().model("gpt-4.1-mini").input("Say hello").build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-4.1-mini",
    "Say hello"
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5require "openai"

client = OpenAI::Client.new
response = client.responses.create(model: "gpt-4.1-mini", input: "Say hello")
puts(response.output_text)

Examples

JavaScript

1
2
3
4
5
6
7
8import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-4.1-mini",
  input: "Say hello",
});

1
2
3
4
5
6
7
8from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-mini",
    input="Say hello",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import (
	"context"
	"fmt"
	"log"

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

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-4.1-mini", Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say hello")},
	})
	if err != nil {
		return err
	}
	fmt.Println(response.OutputText())
	return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder().model("gpt-4.1-mini").input("Say hello").build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-4.1-mini",
    "Say hello"
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5require "openai"

client = OpenAI::Client.new
response = client.responses.create(model: "gpt-4.1-mini", input: "Say hello")
puts(response.output_text)

CodeComparison

Before

1curl https://api.openai.com/v1/responses

After

1curl https://api.openai.com/v1/responses

ContentSwitcher

Node SDK

1
2
3import OpenAI from "openai";

const client = new OpenAI();

DeepDive

Deep dive

Why streaming matters

LatencyExample

Network

End user to API latency

Server

Time to process prompt tokens

Server

Time to sample/generate tokens

Network

API to end user latency

WaveformComponent

Expander

Image

Icon

IconItem

Realtime quickstart

Launch a realtime session and inspect events.

GalleryDocs

Suggested

Get started

Core concepts

SDKs and CLI

Resources

Legacy APIs

Choose a model

Text and code

Prompting

Reasoning

Images

Realtime and audio

Specialized models

Agents API

Agents SDK

ChatKit

Search and retrieval

Connect tools and data

Build tool workflows

Computer and code

Media

GPT-Live

Realtime API

Build with voice

Connections

Audio processing

Go live

Performance and quality

Evaluation

Cost and throughput

Safety and governance

Infrastructure and access

Operations

Core concepts

Plan

Build

Test and publish

Conversion specs

Guides

Resources

Identity

ChatGPT plan usage

Guides

File Upload

API

Measurement

Advertiser API

API Reference

Get started

Get started

Foundations

Explore

Available on

Releases

Workflows

Capabilities

Sites

dots

ChatGPT Space

Reference

Customization

Config file

Agent configuration

Extend ChatGPT and Codex

Linux

Windows

Development workflows

Extend and automate

Environments

Codex Cloud

Build with Codex

Third-party integrations

Reference

Permissions

Codex Security

Cyber safety

Getting started

Feature Configuration

Identity and access

Deployment and configuration