Responses

POST

responses

Create a response

curl --request POST \
  --url https://api.example.com/v1/responses \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "<string>",
  "input": "<string>",
  "instructions": "<string>",
  "max_output_tokens": 2,
  "temperature": 1,
  "top_p": 1,
  "stream": false,
  "tools": [
    {
      "type": "function",
      "name": "<string>",
      "parameters": {},
      "description": "<string>"
    }
  ],
  "parallel_tool_calls": true,
  "text": {
    "format": {
      "type": "text"
    }
  },
  "reasoning": {},
  "metadata": {},
  "truncation": "disabled"
}
'

import requests

url = "https://api.example.com/v1/responses"

payload = {
    "model": "<string>",
    "input": "<string>",
    "instructions": "<string>",
    "max_output_tokens": 2,
    "temperature": 1,
    "top_p": 1,
    "stream": False,
    "tools": [
        {
            "type": "function",
            "name": "<string>",
            "parameters": {},
            "description": "<string>"
        }
    ],
    "parallel_tool_calls": True,
    "text": { "format": { "type": "text" } },
    "reasoning": {},
    "metadata": {},
    "truncation": "disabled"
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    model: '<string>',
    input: '<string>',
    instructions: '<string>',
    max_output_tokens: 2,
    temperature: 1,
    top_p: 1,
    stream: false,
    tools: [{type: 'function', name: '<string>', parameters: {}, description: '<string>'}],
    parallel_tool_calls: true,
    text: {format: {type: 'text'}},
    reasoning: {},
    metadata: {},
    truncation: 'disabled'
  })
};

fetch('https://api.example.com/v1/responses', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/v1/responses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'model' => '<string>',
    'input' => '<string>',
    'instructions' => '<string>',
    'max_output_tokens' => 2,
    'temperature' => 1,
    'top_p' => 1,
    'stream' => false,
    'tools' => [
        [
                'type' => 'function',
                'name' => '<string>',
                'parameters' => [
                                
                ],
                'description' => '<string>'
        ]
    ],
    'parallel_tool_calls' => true,
    'text' => [
        'format' => [
                'type' => 'text'
        ]
    ],
    'reasoning' => [
        
    ],
    'metadata' => [
        
    ],
    'truncation' => 'disabled'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/v1/responses"

	payload := strings.NewReader("{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.example.com/v1/responses")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.example.com/v1/responses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "object": "response",
  "created_at": 123,
  "status": "completed",
  "model": "<string>",
  "output": [
    {
      "type": "message",
      "id": "<string>",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "<string>",
          "annotations": [
            {}
          ]
        }
      ],
      "status": "<string>"
    }
  ],
  "completed_at": 123,
  "usage": {
    "input_tokens": 123,
    "input_tokens_details": {
      "cached_tokens": 123,
      "cache_write_tokens": 123
    },
    "output_tokens": 123,
    "output_tokens_details": {
      "reasoning_tokens": 123
    },
    "total_tokens": 123
  },
  "incomplete_details": {
    "reason": "<string>"
  },
  "error": {},
  "metadata": {},
  "instructions": "<string>",
  "max_output_tokens": 123,
  "parallel_tool_calls": true,
  "temperature": 123,
  "top_p": 123,
  "tool_choice": "<string>",
  "tools": [
    {}
  ],
  "truncation": "<string>",
  "service_tier": "<string>",
  "text": {},
  "reasoning": {}
}

{}

Download the OpenAPI schema for code generation and client libraries.

Model APIs accept requests in the OpenAI Responses API format at https://inference.baseten.co/v1/responses. Use it for the OpenAI Agents SDK and other clients built on the Responses API. Requests are stateless: send the full conversation as input on every call.

Call with the OpenAI SDK

Point the OpenAI client at Baseten and call responses.create:

Python
JavaScript
cURL

To call a model with the Responses API:

responses.py

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)

response = client.responses.create(
    model="zai-org/GLM-5.3",
    instructions="Answer in three words.",
    input="What is the capital of France?",
)

print(response.output_text)

To call a model with the Responses API:

responses.mjs

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.baseten.co/v1",
  apiKey: process.env.BASETEN_API_KEY,
});

const response = await client.responses.create({
  model: "zai-org/GLM-5.3",
  instructions: "Answer in three words.",
  input: "What is the capital of France?",
});

console.log(response.output_text);

To call a model with the Responses API:

Request

curl https://inference.baseten.co/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BASETEN_API_KEY" \
  -d '{
    "model": "zai-org/GLM-5.3",
    "instructions": "Answer in three words.",
    "input": "What is the capital of France?"
  }'

The remaining Python examples on this page reuse client from this section.

Use with the OpenAI Agents SDK

Configure the Agents SDK to use the Responses API, then pass the model as an OpenAIResponsesModel. Agent model names are parsed as <provider>/<model> strings, so a Baseten slug such as zai-org/GLM-5.3 fails with Unknown prefix: zai-org if you pass it as a string. Build the model object instead:

agent.py

import asyncio
import os

from agents import Agent, Runner, set_default_openai_api, set_default_openai_client
from agents.models.openai_responses import OpenAIResponsesModel
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)

set_default_openai_client(client)
set_default_openai_api("responses")

MODEL = OpenAIResponsesModel(model="zai-org/GLM-5.3", openai_client=client)

agent = Agent(
    name="Assistant",
    model=MODEL,
    instructions="Answer in three words.",
)

result = asyncio.run(Runner.run(agent, "What is the capital of France?"))
print(result.final_output)

Tool calls, multi-turn runs, and streaming work through Runner.run and Runner.run_streamed.

Requests are stateless

Baseten stores no response and exposes no retrieval endpoint, so a request can’t refer to an earlier response. To continue a conversation, send the previous output back as part of input:

continue.py

first = client.responses.create(model="zai-org/GLM-5.3", input="Name three countries in South America.")

second = client.responses.create(
    model="zai-org/GLM-5.3",
    input=[*first.output, {"role": "user", "content": "Which of those has the largest population?"}],
)

Stream responses

Set stream to receive server-sent events. Each event carries a type and a sequence_number; token deltas arrive as response.output_text.delta, and the response closes with response.completed:

stream.py

stream = client.responses.create(
    model="zai-org/GLM-5.3",
    input="Write a haiku about GPUs.",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

Call function tools

Declare function tools in tools, then send the model’s call and your function’s result back as input items. A function_call item carries the arguments as a JSON string:

tools.py

import json


def get_weather(city):
    # Replace with a call to your weather service.
    return {"city": city, "temperature_c": 18, "conditions": "cloudy"}


tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    }
]

messages = [{"role": "user", "content": "What is the weather in Paris?"}]
response = client.responses.create(model="zai-org/GLM-5.3", input=messages, tools=tools)

call = next(item for item in response.output if item.type == "function_call")
arguments = json.loads(call.arguments)
result = get_weather(**arguments)

messages = [
    *messages,
    call,
    {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(result)},
]
final = client.responses.create(model="zai-org/GLM-5.3", input=messages, tools=tools)
print(final.output_text)

Return structured output

Set text.format to a JSON schema to constrain the message text:

structured.py

response = client.responses.create(
    model="zai-org/GLM-5.3",
    input="Classify this review: the fans are loud but the screen is gorgeous.",
    text={
        "format": {
            "type": "json_schema",
            "name": "sentiment",
            "schema": {
                "type": "object",
                "properties": {
                    "sentiment": {"type": "string", "enum": ["positive", "negative", "mixed"]},
                    "aspects": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["sentiment", "aspects"],
                "additionalProperties": False,
            },
            "strict": True,
        }
    },
)

print(response.output_text)

Unsupported fields

Baseten serves Responses statelessly, so fields that depend on stored state aren’t supported. The endpoint rejects requests that set previous_response_id, conversation, background, or prompt with HTTP 501; send the full prompt and prior turns as input instead. The endpoint accepts store, but there is no GET /v1/responses/{id} to retrieve a stored response. Store the response yourself if you need to refer to it later.

Body

application/json

model

string

required

Model slug, such as zai-org/GLM-5.3.

input

required

A prompt string, or a list of input items.

instructions

string

System-level instructions for the request.

max_output_tokens

integer

Upper bound on generated tokens, including reasoning tokens.

Required range: x >= 1

temperature

number<float>

default:1

Sampling temperature, from 0 to 2.

Required range: 0 <= x <= 2

top_p

number<float>

default:1

Nucleus sampling threshold, from 0 to 1.

Required range: 0 <= x <= 1

stream

boolean

default:false

Stream server-sent events instead of returning one JSON object.

tools

object[]

Function tools the model can call.

Show child attributes

tool_choice

Whether the model calls a tool. auto lets the model decide, required forces a call, none forbids one.

Available options:

auto,

required,

none

parallel_tool_calls

boolean

default:true

Lets the model emit more than one function call in a response.

text

object

Output format for the message text.

Show child attributes

reasoning

object

Reasoning settings for models that expose them.

Show child attributes

metadata

object

Up to 16 key-value pairs, echoed back on the response.

Show child attributes

truncation

enum<string>

default:disabled

auto or disabled.

Available options:

auto,

disabled

Response

The completed response, or a server-sent event stream when stream is true.

string

required

Response identifier, prefixed resp_.

object

enum<string>

required

Available options:

response

created_at

integer

required

status

enum<string>

required

Available options:

completed,

incomplete,

failed,

in_progress

model

string

required

output

object[]

required

Output items in the order the model produced them.

Option 1
Option 2
Option 3

Show child attributes

completed_at

integer | null

usage

object | null

Show child attributes

incomplete_details

object | null

Show child attributes

error

object | null

metadata

object

Show child attributes

instructions

string | null

max_output_tokens

integer | null

parallel_tool_calls

boolean

temperature

number<float>

top_p

number<float>

tool_choice

string

tools

object[]

truncation

string

service_tier

string

text

object

reasoning

object | null

⌘I

Create a response

curl --request POST \
  --url https://api.example.com/v1/responses \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "<string>",
  "input": "<string>",
  "instructions": "<string>",
  "max_output_tokens": 2,
  "temperature": 1,
  "top_p": 1,
  "stream": false,
  "tools": [
    {
      "type": "function",
      "name": "<string>",
      "parameters": {},
      "description": "<string>"
    }
  ],
  "parallel_tool_calls": true,
  "text": {
    "format": {
      "type": "text"
    }
  },
  "reasoning": {},
  "metadata": {},
  "truncation": "disabled"
}
'

import requests

url = "https://api.example.com/v1/responses"

payload = {
    "model": "<string>",
    "input": "<string>",
    "instructions": "<string>",
    "max_output_tokens": 2,
    "temperature": 1,
    "top_p": 1,
    "stream": False,
    "tools": [
        {
            "type": "function",
            "name": "<string>",
            "parameters": {},
            "description": "<string>"
        }
    ],
    "parallel_tool_calls": True,
    "text": { "format": { "type": "text" } },
    "reasoning": {},
    "metadata": {},
    "truncation": "disabled"
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    model: '<string>',
    input: '<string>',
    instructions: '<string>',
    max_output_tokens: 2,
    temperature: 1,
    top_p: 1,
    stream: false,
    tools: [{type: 'function', name: '<string>', parameters: {}, description: '<string>'}],
    parallel_tool_calls: true,
    text: {format: {type: 'text'}},
    reasoning: {},
    metadata: {},
    truncation: 'disabled'
  })
};

fetch('https://api.example.com/v1/responses', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/v1/responses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'model' => '<string>',
    'input' => '<string>',
    'instructions' => '<string>',
    'max_output_tokens' => 2,
    'temperature' => 1,
    'top_p' => 1,
    'stream' => false,
    'tools' => [
        [
                'type' => 'function',
                'name' => '<string>',
                'parameters' => [
                                
                ],
                'description' => '<string>'
        ]
    ],
    'parallel_tool_calls' => true,
    'text' => [
        'format' => [
                'type' => 'text'
        ]
    ],
    'reasoning' => [
        
    ],
    'metadata' => [
        
    ],
    'truncation' => 'disabled'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/v1/responses"

	payload := strings.NewReader("{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.example.com/v1/responses")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.example.com/v1/responses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"<string>\",\n  \"input\": \"<string>\",\n  \"instructions\": \"<string>\",\n  \"max_output_tokens\": 2,\n  \"temperature\": 1,\n  \"top_p\": 1,\n  \"stream\": false,\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"name\": \"<string>\",\n      \"parameters\": {},\n      \"description\": \"<string>\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"reasoning\": {},\n  \"metadata\": {},\n  \"truncation\": \"disabled\"\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "object": "response",
  "created_at": 123,
  "status": "completed",
  "model": "<string>",
  "output": [
    {
      "type": "message",
      "id": "<string>",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "<string>",
          "annotations": [
            {}
          ]
        }
      ],
      "status": "<string>"
    }
  ],
  "completed_at": 123,
  "usage": {
    "input_tokens": 123,
    "input_tokens_details": {
      "cached_tokens": 123,
      "cache_write_tokens": 123
    },
    "output_tokens": 123,
    "output_tokens_details": {
      "reasoning_tokens": 123
    },
    "total_tokens": 123
  },
  "incomplete_details": {
    "reason": "<string>"
  },
  "error": {},
  "metadata": {},
  "instructions": "<string>",
  "max_output_tokens": 123,
  "parallel_tool_calls": true,
  "temperature": 123,
  "top_p": 123,
  "tool_choice": "<string>",
  "tools": [
    {}
  ],
  "truncation": "<string>",
  "service_tier": "<string>",
  "text": {},
  "reasoning": {}
}

{}

Reference

Inference API

Management API

Loops API

Training API

Frontier Gateway API

Sandbox runtime API

CLI reference

SDKs and clients

Configuration

Metrics

Integrations

Call with the OpenAI SDK

Use with the OpenAI Agents SDK

Requests are stateless

Stream responses

Call function tools

Return structured output

Unsupported fields

Body

Response

​Call with the OpenAI SDK

​Use with the OpenAI Agents SDK

​Requests are stateless

​Stream responses

​Call function tools

​Return structured output

​Unsupported fields

Body

Response

Call with the OpenAI SDK

Use with the OpenAI Agents SDK

Requests are stateless

Stream responses

Call function tools

Return structured output

Unsupported fields