Developer quickstart

For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.

The OpenAI API provides a consistent interface to state-of-the-art AI models for text generation, natural language processing, computer vision, and more. Get started by creating an API Key and running your first API call. Discover how to generate text, analyze images, build agents, and more.

Create and export an API key

StatsigClient.logEvent("quickstart_create_api_key_click", null, null) }

Create an API Key

Before you begin, create an API key in the dashboard, which you'll use to securely access the API. Store the key in a safe location, like a .zshrc file or another text file on your computer. Once you've generated an API key, export it as an environment variable in your terminal.

macOS / Linux

Export an environment variable on macOS or Linux systems

export OPENAI_API_KEY="your_api_key_here"

Windows

Export an environment variable in PowerShell

setx OPENAI_API_KEY "your_api_key_here"

Each OpenAI SDK automatically reads your API key from the system environment.

Install the OpenAI SDK and Run an API Call

JavaScript

To use the OpenAI API in server-side JavaScript environments like Node.js, Deno, or Bun, you can use the official OpenAI SDK for TypeScript and JavaScript. Get started by installing the SDK using npm or your preferred package manager:

Install the OpenAI SDK with npm

npm install openai

With the OpenAI SDK installed, create a file called example.mjs and copy the example code into it:

Test a basic API request

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

Execute the code with node example.mjs (or the equivalent command for Deno or Bun). In a few moments, you should see the output of your API request.

[Learn more on GitHub

  Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-node)

Python

To use the OpenAI API in Python, you can use the official OpenAI SDK for Python. Get started by installing the SDK using pip:

Install the OpenAI SDK with pip

pip install openai

With the OpenAI SDK installed, create a file called example.py and copy the example code into it:

Test a basic API request

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    input="Write a one-sentence bedtime story about a unicorn.",
)

print(response.output_text)

Execute the code with python example.py. In a few moments, you should see the output of your API request.

[Learn more on GitHub

  Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-python)

.NET

In collaboration with Microsoft, OpenAI provides an officially supported API client for C#. You can install it with the .NET CLI from NuGet.

dotnet add package OpenAI

A simple API request to the Responses API would look like this:

Test a basic API request

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

ResponseResult response = await client.CreateResponseAsync(
    "gpt-5.6",
    "Say 'this is a test.'"
);

Console.WriteLine($"[ASSISTANT]: {response.GetOutputText()}");

Java

OpenAI provides an API helper for the Java programming language, currently in beta. You can include the Maven dependency using the following configuration:

<dependency>
  <groupId>com.openai</groupId>
  <artifactId>openai-java</artifactId>
  <version>4.0.0</version>
</dependency>

A simple API request to Responses API would look like this:

Test a basic API request

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

public class Main {
  public static void main(String[] args) {
    OpenAIClient client = OpenAIOkHttpClient.fromEnv();

    ResponseCreateParams params =
        ResponseCreateParams.builder().input("Say this is a test").model("gpt-5.6").build();

    Response response = client.responses().create(params);
    response.output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(outputText -> System.out.println(outputText.text()));
  }
}

To learn more about using the OpenAI API in Java, check out the GitHub repo linked below!

[Learn more on GitHub

  Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-java)

OpenAI provides an API helper for the Go programming language, currently in beta. You can import the library using the code below:

import (
	"github.com/openai/openai-go/v3" // imported as openai
)

A first API request to the Responses API would look like this:

Test a basic API request

package main

import (
	"context"
	"fmt"

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

func main() {
	client := openai.NewClient(
		option.WithAPIKey("My API Key"), // or set OPENAI_API_KEY in your env
	)

	resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
		Model: "gpt-5.6",
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},
	})
	if err != nil {
		panic(err.Error())
	}

	fmt.Println(resp.OutputText())
}

To learn more about using the OpenAI API in Go, check out the GitHub repo linked below!

[Learn more on GitHub

  Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-go)

Ruby

To use the OpenAI API in Ruby, you can use the official OpenAI SDK for Ruby. Get started by adding the gem to your application:

Install the OpenAI SDK with Bundler

gem "openai"

With the OpenAI SDK installed, create a file called example.rb and copy the example code into it:

Test a basic API request

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  input: "Write a one-sentence bedtime story about a unicorn."
)

puts(response.output_text)

Execute the code with ruby example.rb. In a few moments, you should see the output of your API request.

[Learn more on GitHub

  Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-ruby)

[Responses starter app

  Start building with the Responses API.](https://github.com/openai/openai-responses-starter-app)

[Text generation and prompting

  Learn more about prompting, message roles, and building conversational apps.](https://developers.openai.com/api/docs/guides/text)

Add credits to keep building

StatsigClient.logEvent("quickstart_add_credits_billing_click", null, null) }

Go to billing

{/* prettier-ignore */}

Congrats on running a free test API request! Start building real applications with higher limits and use our models to generate text, audio, images, videos and more.

Explore tools and docs designed to help you ship faster:

[StatsigClient.logEvent( "quickstart_add_credits_chat_playground_click", null, null ) }

Chat Playground

  Build & test conversational prompts and embed them in your app.](https://platform.openai.com/chat)

[Build agents

  Use the Agents SDK to build, run, and observe agent workflows.](https://developers.openai.com/api/docs/guides/agents)

Analyze images and files

Send image URLs, uploaded files, or PDF documents directly to the model to extract text, classify content, or detect visual elements.

Image URL

Analyze the content of an image

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "What is in this image?",
        },
        {
          type: "input_image",
          image_url:
            "https://openai-documentation.vercel.app/images/cat_and_otter.png",
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.6",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "What is in this image?"
                    },
                    {
                        "type": "input_image",
                        "image_url": "https://openai-documentation.vercel.app/images/cat_and_otter.png"
                    }
                ]
            }
        ]
}'

openai responses create \
  --model gpt-5.6 \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text' <<'YAML'
input:
  - role: user
    content:
      - type: input_text
        text: What is in this image?
      - type: input_image
        image_url: https://openai-documentation.vercel.app/images/cat_and_otter.png
YAML

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "What teams are playing in this image?",
                },
                {
                    "type": "input_image",
                    "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
                },
            ],
        }
    ],
)

print(response.output_text)

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

Uri imageUrl = new(
    "https://openai-documentation.vercel.app/images/cat_and_otter.png"
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-5.6",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageUrl),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "What teams are playing in this image?"
        },
        {
          type: "input_image",
          image_url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
        }
      ]
    }
  ]
)

puts(response.output_text)

File URL

Use a file URL as input

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.6",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Analyze the letter and provide a summary of the key points."
                    },
                    {
                        "type": "input_file",
                        "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
                    }
                ]
            }
        ]
    }'

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Analyze the letter and provide a summary of the key points.",
        },
        {
          type: "input_file",
          file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
        },
      ],
    },
  ],
});

console.log(response.output_text);

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Analyze the letter and provide a summary of the key points.",
                },
                {
                    "type": "input_file",
                    "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
                },
            ],
        },
    ],
)

print(response.output_text)

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Analyze the letter and provide a summary of the key points."
        },
        {
          type: "input_file",
          file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
        }
      ]
    }
  ]
)

puts(response.output_text)

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

Uri fileUrl = new(
    "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-5.6",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart(
                    "Analyze the letter and provide a summary of the key points."
                ),
                ResponseContentPart.CreateInputFilePart(fileUrl),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

Upload file

Upload a file and use it as input

curl https://api.openai.com/v1/files \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -F purpose="user_data" \
    -F file="@draconomicon.pdf"

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.6",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_file",
                        "file_id": "file-6F2ksmvXxt4VdoqmHRw6kL"
                    },
                    {
                        "type": "input_text",
                        "text": "What is the first dragon in the book?"
                    }
                ]
            }
        ]
    }'

import fs from "fs";
import OpenAI from "openai";
const client = new OpenAI();

const file = await client.files.create({
  file: fs.createReadStream("fixtures/draconomicon.pdf"),
  purpose: "user_data",
});

const response = await client.responses.create({
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_file",
          file_id: file.id,
        },
        {
          type: "input_text",
          text: "What is the first dragon in the book?",
        },
      ],
    },
  ],
});

console.log(response.output_text);

from openai import OpenAI

client = OpenAI()

file = client.files.create(file=open("draconomicon.pdf", "rb"), purpose="user_data")

response = client.responses.create(
    model="gpt-5.6",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id": file.id,
                },
                {
                    "type": "input_text",
                    "text": "What is the first dragon in the book?",
                },
            ],
        }
    ],
)

print(response.output_text)

require "openai"

openai = OpenAI::Client.new

file = openai.files.create(
  file: File.open("draconomicon.pdf", "rb"),
  purpose: "user_data"
)

response = openai.responses.create(
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: [
        {type: "input_file", file_id: file.id},
        {type: "input_text", text: "What is the first dragon in the book?"}
      ]
    }
  ]
)

puts(response.output_text)

using OpenAI.Files;
using OpenAI.Responses;
#pragma warning disable OPENAI001

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

OpenAIFileClient files = new(key);

OpenAIFile file = await files.UploadFileAsync(
    "draconomicon.pdf",
    FileUploadPurpose.UserData
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-5.6",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputFilePart(file.Id),
                ResponseContentPart.CreateInputTextPart(
                    "What is the first dragon in the book?"
                ),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

[Image inputs guide

  Learn to use image inputs to the model and extract meaning from images.](https://developers.openai.com/api/docs/guides/images-vision)

[File inputs guide

  Learn to use file inputs to the model and extract meaning from documents.](https://developers.openai.com/api/docs/guides/file-inputs)

Extend the model with tools

Give the model access to external data and functions by attaching tools. Use built-in tools like web search or file search, or define your own for calling APIs, running code, or integrating with third-party systems.

Web search

Use web search in a response

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  tools: [{ type: "web_search" }],
  input: "What was a positive news story from today?",
});

console.log(response.output_text);

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    tools=[{"type": "web_search"}],
    input="What was a positive news story from today?",
)

print(response.output_text)

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.6",
        "tools": [{"type": "web_search"}],
        "input": "what was a positive news story from today?"
}'

openai responses create \
  --model gpt-5.6 \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text' <<'YAML'
tools:
  - type: web_search
input: What was a positive news story from today?
YAML

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(ResponseTool.CreateWebSearchTool());
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What was a positive news story from today?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  tools: [{type: "web_search"}],
  input: "What was a positive news story from today?"
)

puts(response.output_text)

File search

Search your files in a response

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    input="What is deep research by OpenAI?",
    tools=[{"type": "file_search", "vector_store_ids": ["<vector_store_id>"]}],
)
print(response)

import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-5.6",
  input: "What is deep research by OpenAI?",
  tools: [
    {
      type: "file_search",
      vector_store_ids: ["<vector_store_id>"],
    },
  ],
});
console.log(response);

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateFileSearchTool(["<vector_store_id>"])
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What is deep research by OpenAI?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  input: "What is deep research by OpenAI?",
  tools: [
    {
      type: "file_search",
      vector_store_ids: ["<vector_store_id>"]
    }
  ]
)

puts(response)

Code Interpreter

Use Code Interpreter in a response

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6",
  instructions:
    "You are a personal math tutor. When asked a math question, write and run code to answer the question.",
  tools: [
    {
      type: "code_interpreter",
      container: { type: "auto" },
    },
  ],
  input: "I need to solve the equation 3x + 11 = 14. Can you help me?",
});

console.log(response.output_text);

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6",
    instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    input="I need to solve the equation 3x + 11 = 14. Can you help me?",
)

print(response.output_text)

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.6",
    "instructions": "You are a personal math tutor. When asked a math question, write and run code to answer the question.",
    "tools": [
      {
        "type": "code_interpreter",
        "container": { "type": "auto" }
      }
    ],
    "input": "I need to solve the equation 3x + 11 = 14. Can you help me?"
  }'

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  instructions: "You are a personal math tutor. When asked a math question, write and run code to answer the question.",
  tools: [
    {
      type: "code_interpreter",
      container: {type: "auto"}
    }
  ],
  input: "I need to solve the equation 3x + 11 = 14. Can you help me?"
)

puts(response.output_text)

Function calling

Call your own function

import OpenAI from "openai";
const client = new OpenAI();

/** @type {OpenAI.Responses.Tool[]} */
const tools = [
  {
    type: "function",
    name: "get_weather",
    description: "Get current temperature for a given location.",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City and country e.g. Bogotá, Colombia",
        },
      },
      required: ["location"],
      additionalProperties: false,
    },
    strict: true,
  },
];

const response = await client.responses.create({
  model: "gpt-5.6",
  input: [
    { role: "user", content: "What is the weather like in Paris today?" },
  ],
  tools,
});

console.log(response.output[0]);

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and country e.g. Bogotá, Colombia",
                }
            },
            "required": ["location"],
            "additionalProperties": False,
        },
        "strict": True,
    },
]

response = client.responses.create(
    model="gpt-5.6",
    input=[
        {"role": "user", "content": "What is the weather like in Paris today?"},
    ],
    tools=tools,
)

print(response.output[0].to_json())

using System.Text.Json;
using System.Text.Json.Serialization.Metadata;
using OpenAI.Responses;
#pragma warning disable CA1869
#pragma warning disable OPENAI001

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

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateFunctionTool(
        functionName: "get_weather",
        functionDescription: "Get current temperature for a given location.",
        functionParameters: BinaryData.FromString(
            """
            {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country e.g. Bogotá, Colombia"
                    }
                },
                "required": ["location"],
                "additionalProperties": false
            }
            """
        ),
        strictModeEnabled: true
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What is the weather like in Paris today?")
);

ResponseResult response = client.CreateResponse(options);
Console.WriteLine(
    JsonSerializer.Serialize(
        response.OutputItems[0],
        new JsonSerializerOptions
        {
            TypeInfoResolver = new DefaultJsonTypeInfoResolver(),
        }
    )
);

curl -X POST https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6",
    "input": [
      {"role": "user", "content": "What is the weather like in Paris today?"}
    ],
    "tools": [
      {
        "type": "function",
        "name": "get_weather",
        "description": "Get current temperature for a given location.",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "City and country e.g. Bogotá, Colombia"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        },
        "strict": true
      }
    ]
  }'

require "openai"

openai = OpenAI::Client.new

tools = [
  {
    type: "function",
    name: "get_weather",
    description: "Get current temperature for a given location.",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City and country e.g. Bogotá, Colombia"
        }
      },
      required: ["location"],
      additionalProperties: false
    },
    strict: true
  }
]

response = openai.responses.create(
  model: "gpt-5.6",
  input: [
    {role: "user", content: "What is the weather like in Paris today?"}
  ],
  tools: tools
)

puts(response.output.first.to_json)

Remote MCP

Call a remote MCP server

curl https://api.openai.com/v1/responses \ 
-H "Content-Type: application/json" \ 
-H "Authorization: Bearer $OPENAI_API_KEY" \ 
-d '{
  "model": "gpt-5.6",
    "tools": [
      {
        "type": "mcp",
        "server_label": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Roll 2d4+1"
  }'

import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-5.6",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
    },
  ],
  input: "Roll 2d4+1",
});

console.log(resp.output_text);

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-5.6",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
        },
    ],
    input="Roll 2d4+1",
)

print(resp.output_text)

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

CreateResponseOptions options = new() { Model = "gpt-5.6" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: GlobalMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-5.6",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never"
    }
  ],
  input: "Roll 2d4+1"
)

puts(response.output_text)

[Use built-in tools

  Learn about powerful built-in tools like web search and file search.](https://developers.openai.com/api/docs/guides/tools)

[Function calling guide

  Learn to enable the model to call your own custom code.](https://developers.openai.com/api/docs/guides/function-calling)

Stream responses and build real-time apps

Use server‑sent streaming events to show results as they’re generated, or use the Realtime API for interactive voice apps and apps with text, audio, and image inputs.

Stream server-sent events from the API

import { OpenAI } from "openai";
const client = new OpenAI();

const stream = await client.responses.create({
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: "Say 'double bubble bath' ten times fast.",
    },
  ],
  stream: true,
});

for await (const event of stream) {
  console.log(event);
}

from openai import OpenAI

client = OpenAI()

stream = client.responses.create(
    model="gpt-5.6",
    input=[
        {
            "role": "user",
            "content": "Say 'double bubble bath' ten times fast.",
        },
    ],
    stream=True,
)

for event in stream:
    print(event)

using OpenAI.Responses;
#pragma warning disable OPENAI001

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

var responses = client.CreateResponseStreamingAsync(
    "gpt-5.6",
    "Say 'double bubble bath' ten times fast."
);

await foreach (StreamingResponseUpdate response in responses)
{
    if (response is StreamingResponseOutputTextDeltaUpdate delta)
    {
        Console.Write(delta.Delta);
    }
}

require "openai"

openai = OpenAI::Client.new

stream = openai.responses.stream(
  model: "gpt-5.6",
  input: [
    {
      role: "user",
      content: "Say 'double bubble bath' ten times fast."
    }
  ]
)

stream.each do |event|
  puts(event)
end

[Use streaming events

  Use server-sent events to stream model responses to users fast.](https://developers.openai.com/api/docs/guides/streaming-responses)

[Get started with the Realtime API

  Use WebRTC or WebSockets for super fast speech-to-speech AI apps.](https://developers.openai.com/api/docs/guides/realtime)

Build agents

Use the OpenAI platform to build agents capable of taking action—like controlling computers—on behalf of your users. Use the Agents SDK to create orchestration logic on your server.

Build a language triage agent

import { Agent, run } from "@openai/agents";

const spanishAgent = new Agent({
  name: "Spanish agent",
  instructions: "You only speak Spanish.",
});

const englishAgent = new Agent({
  name: "English agent",
  instructions: "You only speak English",
});

const triageAgent = new Agent({
  name: "Triage agent",
  instructions:
    "Handoff to the appropriate agent based on the language of the request.",
  handoffs: [spanishAgent, englishAgent],
});

const result = await run(triageAgent, "Hola, ¿cómo estás?");
console.log(result.finalOutput);

from agents import Agent, Runner
import asyncio

spanish_agent = Agent(
    name="Spanish agent",
    instructions="You only speak Spanish.",
)

english_agent = Agent(
    name="English agent",
    instructions="You only speak English",
)

triage_agent = Agent(
    name="Triage agent",
    instructions="Handoff to the appropriate agent based on the language of the request.",
    handoffs=[spanish_agent, english_agent],
)


async def main():
    result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

[Build agents that can take action

  Learn how to use the OpenAI platform to build powerful, capable AI agents.](https://developers.openai.com/api/docs/guides/agents)

quickstart.md +496 −198

1# Developer quickstart1# Developer quickstart

2 2

3> For the complete documentation index, see [llms.txt](/llms.txt). Markdown versions of documentation pages are available by appending `.md` to the page URL.

3The OpenAI API provides a consistent interface to state-of-the-art AI [models](https://developers.openai.com/api/docs/models) for text generation, natural language processing, computer vision, and more. Get started by creating an API Key and running your first API call. Discover how to generate text, analyze images, build agents, and more.5The OpenAI API provides a consistent interface to state-of-the-art AI [models](https://developers.openai.com/api/docs/models) for text generation, natural language processing, computer vision, and more. Get started by creating an API Key and running your first API call. Discover how to generate text, analyze images, build agents, and more.

4 6

5## Create and export an API key7## Create and export an API key

12 Create an API Key14 Create an API Key

13 15

14 16

~~15<p></p>~~17

16Before you begin, create an API key in the dashboard, which you'll use to20Before you begin, create an API key in the dashboard, which you'll use to

~~17securely [access the API](https://developers.openai.com/api/docs/api-reference/authentication). Store the key~~21securely [access the API](https://developers.openai.com/api/reference/overview). Store the key

18in a safe location, like a [`.zshrc`22in a safe location, like a [`.zshrc`

19file](https://www.freecodecamp.org/news/how-do-zsh-configuration-files-work/) or23file](https://www.freecodecamp.org/news/how-do-zsh-configuration-files-work/) or

20another text file on your computer. Once you've generated an API key, export it24another text file on your computer. Once you've generated an API key, export it

23 27

24 28

25 29

~~26<div data-content-switcher-pane data-value="macOS">~~30macOS / Linux

~~27 <div class="hidden">macOS / Linux</div>~~31

28 Export an environment variable on macOS or Linux systems32 Export an environment variable on macOS or Linux systems

29 33

30```bash34```bash

31export OPENAI_API_KEY="your_api_key_here"35export OPENAI_API_KEY="your_api_key_here"

32```36```

33 37

~~34 </div>~~38

~~35 <div data-content-switcher-pane data-value="windows" hidden>~~39

~~36 <div class="hidden">Windows</div>~~40

43Windows

37 Export an environment variable in PowerShell45 Export an environment variable in PowerShell

38 46

39```bash47```bash

40setx OPENAI_API_KEY "your_api_key_here"48setx OPENAI_API_KEY "your_api_key_here"

41```49```

42 50

~~43 </div>~~

45 51

46 52

47Each OpenAI SDK automatically reads your API key from the system environment.53Each OpenAI SDK automatically reads your API key from the system environment.

50 56

51 57

52 58

~~53<div data-content-switcher-pane data-value="javascript">~~59JavaScript

~~54 <div class="hidden">JavaScript</div>~~60

~~55 </div>~~61

~~56 <div data-content-switcher-pane data-value="python" hidden>~~62

~~57 <div class="hidden">Python</div>~~63To use the OpenAI API in server-side JavaScript environments like Node.js, Deno, or Bun, you can use the official [OpenAI SDK for TypeScript and JavaScript](https://github.com/openai/openai-node). Get started by installing the SDK using [npm](https://www.npmjs.com/) or your preferred package manager:

~~58 </div>~~64

~~59 <div data-content-switcher-pane data-value="csharp" hidden>~~65Install the OpenAI SDK with npm

~~60 <div class="hidden">.NET</div>~~66

~~61 </div>~~67```bash

~~62 <div data-content-switcher-pane data-value="java" hidden>~~68npm install openai

~~63 <div class="hidden">Java</div>~~69```

~~64 </div>~~70

~~65 <div data-content-switcher-pane data-value="golang" hidden>~~71

~~66 <div class="hidden">Go</div>~~72With the OpenAI SDK installed, create a file called `example.mjs` and copy the example code into it:

~~67 </div>~~73

~~68 <div data-content-switcher-pane data-value="ruby" hidden>~~74Test a basic API request

~~69 <div class="hidden">Ruby</div>~~75

~~70 </div>~~76```javascript

71 77import OpenAI from "openai";

72 78const client = new OpenAI();

~~73<a~~79

~~74 href="https://github.com/openai/openai-responses-starter-app"~~80const response = await client.responses.create({

~~75 target="_blank"~~81 model: "gpt-5.6",

~~76 rel="noreferrer"~~82 input: "Write a one-sentence bedtime story about a unicorn.",

~~77>~~83});

85console.log(response.output_text);

86```

89Execute the code with `node example.mjs` (or the equivalent command for Deno or Bun). In a few moments, you should see the output of your API request.

91[Learn more on GitHub

95 Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-node)

100

101

102

103Python

104

105

106

107To use the OpenAI API in Python, you can use the official [OpenAI SDK for Python](https://github.com/openai/openai-python). Get started by installing the SDK using [pip](https://pypi.org/project/pip/):

108

109Install the OpenAI SDK with pip

110

111```bash

112pip install openai

113```

114

115

116With the OpenAI SDK installed, create a file called `example.py` and copy the example code into it:

117

118Test a basic API request

119

120```python

121from openai import OpenAI

122

123client = OpenAI()

124

125response = client.responses.create(

126 model="gpt-5.6",

127 input="Write a one-sentence bedtime story about a unicorn.",

128)

129

130print(response.output_text)

131```

132

133

134Execute the code with `python example.py`. In a few moments, you should see the output of your API request.

135

136[Learn more on GitHub

137

138

139

140 Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-python)

141

142

143

144

145

146

147

148.NET

149

150

151

152In collaboration with Microsoft, OpenAI provides an officially supported API client for C#. You can install it with the .NET CLI from [NuGet](https://www.nuget.org/).

153

154```

155dotnet add package OpenAI

156```

157

158A simple API request to the [Responses API](https://developers.openai.com/api/reference/resources/responses) would look like this:

159

160Test a basic API request

161

162```csharp

163using OpenAI.Responses;

164#pragma warning disable OPENAI001

165

166string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

167ResponsesClient client = new(key);

168

169ResponseResult response = await client.CreateResponseAsync(

170 "gpt-5.6",

171 "Say 'this is a test.'"

172);

173

174Console.WriteLine($"[ASSISTANT]: {response.GetOutputText()}");

175```

176

177

178

179

180

181

182

183Java

184

185

186

187OpenAI provides an API helper for the Java programming language, currently in beta. You can include the Maven dependency using the following configuration:

188

189```xml

190<dependency>

191 <groupId>com.openai</groupId>

192 <artifactId>openai-java</artifactId>

193 <version>4.0.0</version>

194</dependency>

195```

196

197A simple API request to [Responses API](https://developers.openai.com/api/reference/resources/responses) would look like this:

198

199Test a basic API request

200

201```java

202import com.openai.client.OpenAIClient;

203import com.openai.client.okhttp.OpenAIOkHttpClient;

204import com.openai.models.responses.Response;

205import com.openai.models.responses.ResponseCreateParams;

206

207public class Main {

208 public static void main(String[] args) {

209 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

210

211 ResponseCreateParams params =

212 ResponseCreateParams.builder().input("Say this is a test").model("gpt-5.6").build();

213

214 Response response = client.responses().create(params);

215 response.output().stream()

216 .flatMap(item -> item.message().stream())

217 .flatMap(message -> message.content().stream())

218 .flatMap(content -> content.outputText().stream())

219 .forEach(outputText -> System.out.println(outputText.text()));

220 }

221}

222```

223

224

225To learn more about using the OpenAI API in Java, check out the GitHub repo linked below!

226

227[Learn more on GitHub

228

229

230

231 Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-java)

232

233

234

235

236

237

238

239Go

240

241

242

243OpenAI provides an API helper for the Go programming language, currently in beta. You can import the library using the code below:

244

245```go

246import (

247 "github.com/openai/openai-go/v3" // imported as openai

248)

249```

250

251

252A first API request to the [Responses API](https://developers.openai.com/api/reference/resources/responses) would look like this:

253

254Test a basic API request

255

256```go

257package main

258

259import (

260 "context"

261 "fmt"

262

263 "github.com/openai/openai-go/v3"

264 "github.com/openai/openai-go/v3/option"

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

266)

267

268func main() {

269 client := openai.NewClient(

270 option.WithAPIKey("My API Key"), // or set OPENAI_API_KEY in your env

271 )

272

273 resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{

274 Model: "gpt-5.6",

275 Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},

276 })

277 if err != nil {

278 panic(err.Error())

279 }

280

281 fmt.Println(resp.OutputText())

282}

283```

284

285

286To learn more about using the OpenAI API in Go, check out the GitHub repo linked below!

287

288[Learn more on GitHub

289

290

291

292 Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-go)

293

78 294

79 295

~~80<span slot="icon">~~

~~81 </span>~~

~~82 Start building with the Responses API.~~

83 296

84 297

~~85</a>~~

86 298

~~87[~~

88 299

~~89<span slot="icon">~~300Ruby

~~90 </span>~~

~~91 Learn more about prompting, message roles, and building conversational apps.~~

92 301

~~93](https://developers.openai.com/api/docs/guides/text)~~302

303

304To use the OpenAI API in Ruby, you can use the official [OpenAI SDK for Ruby](https://github.com/openai/openai-ruby). Get started by adding the gem to your application:

305

306Install the OpenAI SDK with Bundler

307

308```ruby

309gem "openai"

310```

311

312

313With the OpenAI SDK installed, create a file called `example.rb` and copy the example code into it:

314

315Test a basic API request

316

317```ruby

318require "openai"

319

320openai = OpenAI::Client.new

321

322response = openai.responses.create(

323 model: "gpt-5.6",

324 input: "Write a one-sentence bedtime story about a unicorn."

325)

326

327puts(response.output_text)

328```

329

330

331Execute the code with `ruby example.rb`. In a few moments, you should see the output of your API request.

332

333[Learn more on GitHub

334

335

336

337 Discover more SDK capabilities and options on the library's GitHub README.](https://github.com/openai/openai-ruby)

338

339

340[Responses starter app

341

342

343

344 Start building with the Responses API.](https://github.com/openai/openai-responses-starter-app)

345

346[Text generation and prompting

347

348

349

350 Learn more about prompting, message roles, and building conversational apps.](https://developers.openai.com/api/docs/guides/text)

94 351

95## Add credits to keep building352## Add credits to keep building

96 353

103 360

104 361

105{/* prettier-ignore */}362{/* prettier-ignore */}

106<div className="mt-2">Congrats on running a free test API request! Start building real applications with higher limits and use <a href="/api/docs/models" target="_blank">our models</a> to generate text, audio, images, videos and more.</div>

107 363

108<div className="mt-2">364Congrats on running a free test API request! Start building real applications with higher limits and use [our models](https://developers.openai.com/api/docs/models) to generate text, audio, images, videos and more.

365

366

367

368

109 Explore tools and docs designed to help you ship faster:369 Explore tools and docs designed to help you ship faster:

110</div>370

111<a371

112 href="https://platform.openai.com/chat"372[StatsigClient.logEvent(

113 target="_blank"

114 rel="noreferrer"

115 onClick={() =>

116 StatsigClient.logEvent(

117 "quickstart_add_credits_chat_playground_click",373 "quickstart_add_credits_chat_playground_click",

118 null,374 null,

119 null375 null

120 )376 )

121 }377 }

122>378>

379 Chat Playground

123 380

124 381

125<span slot="icon">

126 </span>

127 Build & test conversational prompts and embed them in your app.

128 382

383 Build & test conversational prompts and embed them in your app.](https://platform.openai.com/chat)

384[Build agents

129 385

130</a>

131[

132 386

133<span slot="icon">

134 </span>

135 Use the Agents SDK to build, run, and observe agent workflows.

136 387

137](https://developers.openai.com/api/docs/guides/agents)388 Use the Agents SDK to build, run, and observe agent workflows.](https://developers.openai.com/api/docs/guides/agents)

138 389

139## Analyze images and files390## Analyze images and files

140 391

142 393

143 394

144 395

145<div data-content-switcher-pane data-value="image-url">396Image URL

146 <div class="hidden">Image URL</div>397

147 Analyze the content of an image398 Analyze the content of an image

148 399

149```javascript400```javascript

242 493

243```csharp494```csharp

244using OpenAI.Responses;495using OpenAI.Responses;

496#pragma warning disable OPENAI001

245 497

246string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;498string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

247OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);499ResponsesClient client = new(key);

500

501Uri imageUrl = new(

502 "https://openai-documentation.vercel.app/images/cat_and_otter.png"

503);

248 504

249OpenAIResponse response = (OpenAIResponse)client.CreateResponse([505ResponseResult response = await client.CreateResponseAsync(

250 ResponseItem.CreateUserMessageItem([506 "gpt-5.6",

507 [

508 ResponseItem.CreateUserMessageItem(

509 [

251 ResponseContentPart.CreateInputTextPart("What is in this image?"),510 ResponseContentPart.CreateInputTextPart("What is in this image?"),

252 ResponseContentPart.CreateInputImagePart(new Uri("https://openai-documentation.vercel.app/images/cat_and_otter.png")),511 ResponseContentPart.CreateInputImagePart(imageUrl),

253 ]),512 ]

254]);513 ),

514 ]

515);

255 516

256Console.WriteLine(response.GetOutputText());517Console.WriteLine(response.GetOutputText());

257```518```

283puts(response.output_text)544puts(response.output_text)

284```545```

285 546

286 </div>547

287 <div data-content-switcher-pane data-value="file-url" hidden>548

288 <div class="hidden">File URL</div>549

550

551

552File URL

553

289 Use a file URL as input554 Use a file URL as input

290 555

291```bash556```bash

393```658```

394 659

395```csharp660```csharp

396using OpenAI.Files;

397using OpenAI.Responses;661using OpenAI.Responses;

662#pragma warning disable OPENAI001

398 663

399string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;664string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

400OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);665ResponsesClient client = new(key);

401 666

402using HttpClient http = new();667Uri fileUrl = new(

403using Stream stream = await http.GetStreamAsync("https://www.berkshirehathaway.com/letters/2024ltr.pdf");668 "https://www.berkshirehathaway.com/letters/2024ltr.pdf"

404OpenAIFileClient files = new(key);669);

405OpenAIFile file = files.UploadFile(stream, "2024ltr.pdf", FileUploadPurpose.UserData);

406 670

407OpenAIResponse response = (OpenAIResponse)client.CreateResponse([671ResponseResult response = await client.CreateResponseAsync(

408 ResponseItem.CreateUserMessageItem([672 "gpt-5.6",

409 ResponseContentPart.CreateInputTextPart("Analyze the letter and provide a summary of the key points."),673 [

410 ResponseContentPart.CreateInputFilePart(file.Id),674 ResponseItem.CreateUserMessageItem(

411 ]),675 [

412]);676 ResponseContentPart.CreateInputTextPart(

677 "Analyze the letter and provide a summary of the key points."

678 ),

679 ResponseContentPart.CreateInputFilePart(fileUrl),

680 ]

681 ),

682 ]

683);

413 684

414Console.WriteLine(response.GetOutputText());685Console.WriteLine(response.GetOutputText());

415```686```

416 687

417 </div>688

418 <div data-content-switcher-pane data-value="file-upload" hidden>689

419 <div class="hidden">Upload file</div>690

691

692

693Upload file

694

420 Upload a file and use it as input695 Upload a file and use it as input

421 696

422```bash697```bash

538```csharp813```csharp

539using OpenAI.Files;814using OpenAI.Files;

540using OpenAI.Responses;815using OpenAI.Responses;

816#pragma warning disable OPENAI001

541 817

542string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;818string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

543OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);819ResponsesClient client = new(key);

544 820

545OpenAIFileClient files = new(key);821OpenAIFileClient files = new(key);

546OpenAIFile file = files.UploadFile("draconomicon.pdf", FileUploadPurpose.UserData);

547 822

548OpenAIResponse response = (OpenAIResponse)client.CreateResponse([823OpenAIFile file = await files.UploadFileAsync(

549 ResponseItem.CreateUserMessageItem([824 "draconomicon.pdf",

825 FileUploadPurpose.UserData

826);

827

828ResponseResult response = await client.CreateResponseAsync(

829 "gpt-5.6",

830 [

831 ResponseItem.CreateUserMessageItem(

832 [

550 ResponseContentPart.CreateInputFilePart(file.Id),833 ResponseContentPart.CreateInputFilePart(file.Id),

551 ResponseContentPart.CreateInputTextPart("What is the first dragon in the book?"),834 ResponseContentPart.CreateInputTextPart(

552 ]),835 "What is the first dragon in the book?"

553]);836 ),

837 ]

838 ),

839 ]

840);

554 841

555Console.WriteLine(response.GetOutputText());842Console.WriteLine(response.GetOutputText());

556```843```

557 844

558 </div>

559 845

560 846

847[Image inputs guide

848

561 849

562[

563 850

564<span slot="icon">851 Learn to use image inputs to the model and extract meaning from images.](https://developers.openai.com/api/docs/guides/images-vision)

565 </span>

566 Learn to use image inputs to the model and extract meaning from images.

567 852

568](https://developers.openai.com/api/docs/guides/images)853[File inputs guide

569 854

570[

571 855

572<span slot="icon">

573 </span>

574 Learn to use file inputs to the model and extract meaning from documents.

575 856

576](https://developers.openai.com/api/docs/guides/file-inputs)857 Learn to use file inputs to the model and extract meaning from documents.](https://developers.openai.com/api/docs/guides/file-inputs)

577 858

578## Extend the model with tools859## Extend the model with tools

579 860

581 862

582 863

583 864

584<div data-content-switcher-pane data-value="web-search">865Web search

585 <div class="hidden">Web search</div>866

586 Use web search in a response867 Use web search in a response

587 868

588```javascript869```javascript

636 917

637```csharp918```csharp

638using OpenAI.Responses;919using OpenAI.Responses;

920#pragma warning disable OPENAI001

639 921

640string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;922string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

641OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);923ResponsesClient client = new(key);

642 924

643ResponseCreationOptions options = new();925CreateResponseOptions options = new() { Model = "gpt-5.6" };

644options.Tools.Add(ResponseTool.CreateWebSearchTool());926options.Tools.Add(ResponseTool.CreateWebSearchTool());

927options.InputItems.Add(

928 ResponseItem.CreateUserMessageItem("What was a positive news story from today?")

929);

645 930

646OpenAIResponse response = (OpenAIResponse)client.CreateResponse([931ResponseResult response = await client.CreateResponseAsync(options);

647 ResponseItem.CreateUserMessageItem([

648 ResponseContentPart.CreateInputTextPart("What was a positive news story from today?"),

649 ]),

650], options);

651 932

652Console.WriteLine(response.GetOutputText());933Console.WriteLine(response.GetOutputText());

653```934```

666puts(response.output_text)947puts(response.output_text)

667```948```

668 949

669 </div>950

670 <div data-content-switcher-pane data-value="file-search" hidden>951

671 <div class="hidden">File search</div>952

953

954

955File search

956

672 Search your files in a response957 Search your files in a response

673 958

674```python959```python

703 988

704```csharp989```csharp

705using OpenAI.Responses;990using OpenAI.Responses;

991#pragma warning disable OPENAI001

706 992

707string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;993string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

708OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);994ResponsesClient client = new(key);

709 995

710ResponseCreationOptions options = new();996CreateResponseOptions options = new() { Model = "gpt-5.6" };

711options.Tools.Add(ResponseTool.CreateFileSearchTool(["<vector_store_id>"]));997options.Tools.Add(

998 ResponseTool.CreateFileSearchTool(["<vector_store_id>"])

999);

1000options.InputItems.Add(

1001 ResponseItem.CreateUserMessageItem("What is deep research by OpenAI?")

1002);

712 1003

713OpenAIResponse response = (OpenAIResponse)client.CreateResponse([1004ResponseResult response = await client.CreateResponseAsync(options);

714 ResponseItem.CreateUserMessageItem([

715 ResponseContentPart.CreateInputTextPart("What is deep research by OpenAI?"),

716 ]),

717], options);

718 1005

719Console.WriteLine(response.GetOutputText());1006Console.WriteLine(response.GetOutputText());

720```1007```

738puts(response)1025puts(response)

739```1026```

740 1027

741 </div>1028

742 <div data-content-switcher-pane data-value="code-interpreter" hidden>1029

743 <div class="hidden">Code Interpreter</div>1030

1031

1032

1033Code Interpreter

1034

744 Use Code Interpreter in a response1035 Use Code Interpreter in a response

745 1036

746```javascript1037```javascript

815puts(response.output_text)1106puts(response.output_text)

816```1107```

817 1108

818 </div>1109

819 <div data-content-switcher-pane data-value="function-calling" hidden>1110

820 <div class="hidden">Function calling</div>1111

1112

1113

1114Function calling

1115

821 Call your own function1116 Call your own function

822 1117

823```javascript1118```javascript

894 1189

895```csharp1190```csharp

896using System.Text.Json;1191using System.Text.Json;

1192using System.Text.Json.Serialization.Metadata;

897using OpenAI.Responses;1193using OpenAI.Responses;

1194#pragma warning disable CA1869

1195#pragma warning disable OPENAI001

898 1196

899string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;1197string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

900OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);1198ResponsesClient client = new(key);

901 1199

902ResponseCreationOptions options = new();1200CreateResponseOptions options = new() { Model = "gpt-5.6" };

903options.Tools.Add(ResponseTool.CreateFunctionTool(1201options.Tools.Add(

1202 ResponseTool.CreateFunctionTool(

904 functionName: "get_weather",1203 functionName: "get_weather",

905 functionDescription: "Get current temperature for a given location.",1204 functionDescription: "Get current temperature for a given location.",

906 functionParameters: BinaryData.FromObjectAsJson(new1205 functionParameters: BinaryData.FromString(

907 {1206 """

908 type = "object",

909 properties = new

910 {1207 {

911 location = new1208 "type": "object",

912 {1209 "properties": {

913 type = "string",1210 "location": {

914 description = "City and country e.g. Bogotá, Colombia"1211 "type": "string",

1212 "description": "City and country e.g. Bogotá, Colombia"

915 }1213 }

916 },1214 },

917 required = new[] { "location" },1215 "required": ["location"],

918 additionalProperties = false1216 "additionalProperties": false

919 }),1217 }

1218 """

1219 ),

920 strictModeEnabled: true1220 strictModeEnabled: true

921 )1221 )

922);1222);

1223options.InputItems.Add(

1224 ResponseItem.CreateUserMessageItem("What is the weather like in Paris today?")

1225);

923 1226

924OpenAIResponse response = (OpenAIResponse)client.CreateResponse([1227ResponseResult response = client.CreateResponse(options);

925 ResponseItem.CreateUserMessageItem([1228Console.WriteLine(

926 ResponseContentPart.CreateInputTextPart("What is the weather like in Paris today?")1229 JsonSerializer.Serialize(

927 ])1230 response.OutputItems[0],

928], options);1231 new JsonSerializerOptions

~~929~~ 1232 {

930Console.WriteLine(JsonSerializer.Serialize(response.OutputItems[0]));1233 TypeInfoResolver = new DefaultJsonTypeInfoResolver(),

1234 }

1235 )

1236);

931```1237```

932 1238

933```bash1239```bash

997puts(response.output.first.to_json)1303puts(response.output.first.to_json)

998```1304```

999 1305

1000 </div>1306

1001 <div data-content-switcher-pane data-value="remote-mcp" hidden>1307

1002 <div class="hidden">Remote MCP</div>1308

1309

1310

1311Remote MCP

1312

1003 Call a remote MCP server1313 Call a remote MCP server

1004 1314

1005```bash1315```bash

1067 1377

1068```csharp1378```csharp

1069using OpenAI.Responses;1379using OpenAI.Responses;

1380#pragma warning disable OPENAI001

1070 1381

1071string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;1382string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1072OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);1383ResponsesClient client = new(key);

1073 1384

1074ResponseCreationOptions options = new();1385CreateResponseOptions options = new() { Model = "gpt-5.6" };

1075options.Tools.Add(ResponseTool.CreateMcpTool(1386options.Tools.Add(

1387 ResponseTool.CreateMcpTool(

1076 serverLabel: "dmcp",1388 serverLabel: "dmcp",

1077 serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),1389 serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),

1078 toolCallApprovalPolicy: new McpToolCallApprovalPolicy(GlobalMcpToolCallApprovalPolicy.NeverRequireApproval)1390 toolCallApprovalPolicy: GlobalMcpToolCallApprovalPolicy.NeverRequireApproval

1079));1391 )

1392);

1393options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

1080 1394

1081OpenAIResponse response = (OpenAIResponse)client.CreateResponse([1395ResponseResult response = await client.CreateResponseAsync(options);

1082 ResponseItem.CreateUserMessageItem([

1083 ResponseContentPart.CreateInputTextPart("Roll 2d4+1")

1084 ])

1085], options);

1086 1396

1087Console.WriteLine(response.GetOutputText());1397Console.WriteLine(response.GetOutputText());

1088```1398```

1109puts(response.output_text)1419puts(response.output_text)

1110```1420```

1111 1421

1112 </div>

1113 1422

1114 1423

1424[Use built-in tools

1425

1115 1426

1116[

1117 1427

1118<span slot="icon">1428 Learn about powerful built-in tools like web search and file search.](https://developers.openai.com/api/docs/guides/tools)

1119 </span>

1120 Learn about powerful built-in tools like web search and file search.

1121 1429

1122](https://developers.openai.com/api/docs/guides/tools)1430[Function calling guide

1123 1431

1124[

1125 1432

1126<span slot="icon">

1127 </span>

1128 Learn to enable the model to call your own custom code.

1129 1433

1130](https://developers.openai.com/api/docs/guides/function-calling)1434 Learn to enable the model to call your own custom code.](https://developers.openai.com/api/docs/guides/function-calling)

1131 1435

1132## Stream responses and build real-time apps1436## Stream responses and build real-time apps

1133 1437

1177 1481

1178```csharp1482```csharp

1179using OpenAI.Responses;1483using OpenAI.Responses;

1484#pragma warning disable OPENAI001

1180 1485

1181string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;1486string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1182OpenAIResponseClient client = new(model: "gpt-5.6", apiKey: key);1487ResponsesClient client = new(key);

1183 1488

1184var responses = client.CreateResponseStreamingAsync([1489var responses = client.CreateResponseStreamingAsync(

1185 ResponseItem.CreateUserMessageItem([1490 "gpt-5.6",

1186 ResponseContentPart.CreateInputTextPart("Say 'double bubble bath' ten times fast."),1491 "Say 'double bubble bath' ten times fast."

1187 ]),1492);

1188]);

1189 1493

1190await foreach (var response in responses)1494await foreach (StreamingResponseUpdate response in responses)

1191{1495{

1192 if (response is StreamingResponseOutputTextDeltaUpdate delta)1496 if (response is StreamingResponseOutputTextDeltaUpdate delta)

1193 {1497 {

1217```1521```

1218 1522

1219 1523

1220[1524[Use streaming events

1525

1221 1526

1222<span slot="icon">

1223 </span>

1224 Use server-sent events to stream model responses to users fast.

1225 1527

1226](https://developers.openai.com/api/docs/guides/streaming-responses)1528 Use server-sent events to stream model responses to users fast.](https://developers.openai.com/api/docs/guides/streaming-responses)

1227 1529

1228[1530[Get started with the Realtime API

1229 1531

1230<span slot="icon">

1231 </span>

1232 Use WebRTC or WebSockets for super fast speech-to-speech AI apps.

1233 1532

1234](https://developers.openai.com/api/docs/guides/realtime)1533

1534 Use WebRTC or WebSockets for super fast speech-to-speech AI apps.](https://developers.openai.com/api/docs/guides/realtime)

1235 1535

1236## Build agents1536## Build agents

1237 1537

1294```1594```

1295 1595

1296 1596

1297[1597[Build agents that can take action

1598

1298 1599

1299<span slot="icon">

1300 </span>

1301 Learn how to use the OpenAI platform to build powerful, capable AI agents.

1302 1600

1303](https://developers.openai.com/api/docs/guides/agents)1601 Learn how to use the OpenAI platform to build powerful, capable AI agents.](https://developers.openai.com/api/docs/guides/agents)

quickstart.md 2026-07-27 17:02 UTC to 2026-07-28 23:01 UTC

Developer quickstart

Create and export an API key

Install the OpenAI SDK and Run an API Call

Add credits to keep building

Analyze images and files

Extend the model with tools

Stream responses and build real-time apps

Build agents