OpenAI Responses API Setup: 13 Steps [2026]

Nadia Dubois
October 10, 2026
22 min read

OpenAI’s Responses API has quietly become the default way to build serious applications on top of GPT models, and the September-to-October 2026 run of releases gave developers a real reason to migrate off the older Chat Completions endpoint. GPT-6.1 Sol shipped on September 29, 2026, priced at $2 per million input tokens and $10 per million output tokens, and on October 8 OpenAI layered an Ultrafast processing tier on top of it inside the Responses API. Together they change how fast, how cheap, and how statefully you can run production AI workloads. This tutorial walks through the full setup: creating keys, installing the current SDKs, sending your first call, turning on Ultrafast mode, wiring up tools, caching prompts, handling errors, and shipping a complete working project you can copy today.

Don’t miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

What Is the OpenAI Responses API, and Why It’s Trending Right Now

The Responses API is OpenAI’s unified request primitive, built to replace both the older Chat Completions API and the now-deprecated Assistants API. Instead of juggling separate endpoints for stateless chat, file search, and persistent assistants, a single /v1/responses endpoint now handles text generation, tool calls, file inputs, multi-turn state, and background processing. OpenAI’s own migration guide frames this as “added simplicity and powerful agentic primitives” layered on top of what Chat Completions already did well.

Search interest backs up what the changelog suggests. The query “openai responses api” pulls roughly 2,400 monthly searches in the US with low ranking competition, well ahead of niche terms like “openai responses api documentation” or “openai responses api python.” That gap between search volume and available how-to content is exactly why this guide exists: most of what ranks today is either OpenAI’s own reference docs or a thin rewrite of them, not a walkthrough that covers the new GPT-6.1 Sol Ultrafast tier end to end.

Two structural differences separate the Responses API from Chat Completions. First, responses are stored server-side by default (you can disable this with a store flag), while Chat Completions only started doing that for new accounts. Second, the response object you get back is a typed response with its own id, rather than a bare message, which makes it far easier to reference a prior turn, cancel an in-flight generation, or resume a background job later. Gartner’s enterprise research backs the urgency: the firm projects that more than 80% of enterprises will have used generative AI APIs or deployed generative-AI-enabled applications in production by 2026, up from under 5% in 2023, and that over 30% of all new API demand growth is coming directly from AI and LLM tooling, according to IDC’s 2025 generative AI software development research.

GPT-6.1 Sol and Ultrafast Mode: What Actually Shipped This Fall

GPT-6.1 Sol launched on September 29, 2026, as a mid-tier model sitting between the flagship GPT-6 Astra and the budget GPT-6 Luna. OpenAI’s own model page describes it as delivering “near-Astra performance for complex work at a lower cost,” which lines up with its pricing: $2 per million input tokens and $10 per million output tokens, against $10 and $50 for Astra. Cached input tokens on Sol run just $0.10 per million, a 95% discount off the standard input rate once a prompt prefix has already been processed once.

Sol carries a 1.05-million-token context window and a 128,000-token maximum output, with a knowledge cutoff of April 30, 2026. It’s reachable through the Responses API under the model identifier gpt-6.1-sol, and it supports function calling, web search, file search, and computer-use tools natively, with data residency limited to the US and the EU.

The bigger news for this tutorial is what landed in the Responses API changelog on October 8: Ultrafast mode. Set the service_tier parameter to "ultrafast" on a gpt-6.1-sol request and OpenAI cuts the time between generated output tokens, which matters most for latency-sensitive interfaces like voice agents or live coding assistants. It’s open to every API user, subject to standard rate limits, and it works across both US and EU data residency regions with global request routing. It sits alongside the existing Fast mode and the much cheaper Batch and Flex tiers, which together give you four distinct speed-versus-cost dials on the same model.

For context on how Sol compares against its siblings and against Google’s competing release, our earlier GPT-6.1 Sol vs Gemini 4 Argon breakdown covers the benchmark gap in more depth. This piece focuses purely on getting a working integration running.

Prerequisites: Accounts, SDKs, and Versions You’ll Need

Before writing any code, get these in place. None of them are optional, and version mismatches are the single most common reason this setup fails on a fresh machine.

You’ll also want roughly 90 minutes set aside for the full walkthrough, including the complete project build in Step 12. If you’ve already set up a different provider’s API, the authentication pattern here is nearly identical to what we covered in the Mistral Large 4 API setup guide and the Claude Sonnet 5.5 API tutorial, so a lot of this will feel familiar if you’ve worked through either of those.

Step 1: Create an API Key and a Dedicated Project

Log into the OpenAI platform dashboard and open the Projects panel. Create a new project specifically for this tutorial rather than reusing a personal default project. Isolating work this way means you can set a hard spend limit, rotate the key without breaking anything else, and read clean usage logs later when you’re trying to figure out what a given feature actually costs.

Inside the project, generate a new secret key and copy it immediately since OpenAI will not show it again. Store it as an environment variable rather than hardcoding it anywhere:

export OPENAI_API_KEY="sk-proj-your-key-here"
echo 'export OPENAI_API_KEY="sk-proj-your-key-here"' >> ~/.zshrc

On Windows, use setx OPENAI_API_KEY "sk-proj-your-key-here" in PowerShell, then restart your terminal so the variable loads. While you’re in the dashboard, set a monthly spend cap on the project. A typo in a loop that calls the Responses API in a retry storm can burn through a surprising amount of budget overnight, and a cap is the cheapest insurance you’ll buy today.

Step 2: Install the Current Python and Node.js SDKs

Both official SDKs got GPT-6.1 Sol support in their October 9, 2026 releases. Pin to those versions or newer so the service_tier parameter and the newer response fields are available.

# Python
pip install --upgrade "openai>=3.28.0"

# Node.js / TypeScript
npm install [email protected]

Verify the install worked and picked up the right version before moving on:

python3 -c "import openai; print(openai.__version__)"
node -e "console.log(require('openai/package.json').version)"

If you’re working in a virtual environment (recommended), activate it before running the pip install so the package doesn’t land in your global site-packages. A stale global install of an older openai package is the most common reason developers report a missing service_tier argument later in this guide.

Step 3: Send Your First Responses API Call

With the key exported and the SDK installed, the minimal request looks like this in Python:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    input="Summarize the main risk of running a database migration during peak traffic."
)

print(response.output_text)

And the equivalent in Node.js:

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6.1-sol",
  input: "Summarize the main risk of running a database migration during peak traffic.",
});

console.log(response.output_text);

Run either script and you should see a short, direct paragraph of generated text print to your terminal within a couple of seconds, something like:

Running a schema migration during peak traffic risks locking tables that
active read/write queries depend on, which can cascade into request
timeouts, connection pool exhaustion, and, for long-running ALTER
statements on large tables, a full application outage until the
migration completes or is rolled back.

If you’d rather test from the command line without writing any code, curl works the same way:

curl https://api.openai.com/v1/responses 
  -H "Content-Type: application/json" 
  -H "Authorization: Bearer $OPENAI_API_KEY" 
  -d '{
    "model": "gpt-6.1-sol",
    "input": "Write one sentence describing what a load balancer does."
  }'

That curl call returns the full JSON response object, including the generated text under an output array, a usage block with token counts, and a response.id you can reference in a follow-up call. Keep that id handy, it’s the key to the multi-turn state covered in Step 8. OpenAI’s own getting-started quickstart runs through the same first call if you want a second reference point while you’re testing.

Step 4: Choose the Right Model: Sol, Astra, or Luna

GPT-6.1 Sol isn’t the only model behind the Responses API, and picking the wrong one for a given workload is an easy way to overpay or under-deliver. OpenAI currently ships three tiers on the same endpoint:

Astra is the model to reach for on heavy reasoning, large codebases, or anything where the output quality gap is worth 5x the cost of Sol. Sol is the practical default for most production apps: agentic workflows, coding assistants, and customer-facing chat where near-Astra quality at a fifth of the price makes the budget math work. Luna is built for high-volume, low-complexity jobs like classification, tagging, or simple extraction where cost per call matters more than nuance. Swapping between them only requires changing one string:

for model_id in ["gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna"]:
    response = client.responses.create(model=model_id, input="Explain CAP theorem in two sentences.")
    print(model_id, "->", response.output_text[:120])

Run that loop once against a representative prompt from your own application before committing to a model. The quality difference between Sol and Astra is real but workload-dependent, and it’s a five-minute test that can save a meaningful chunk of your monthly bill.

Step 5: Turn On Ultrafast Mode

Ultrafast mode is the headline addition to the Responses API this cycle, and enabling it is a one-line change. Add service_tier="ultrafast" to any gpt-6.1-sol request:

response = client.responses.create(
    model="gpt-6.1-sol",
    input="Give a one-line status update: deployment succeeded, no errors.",
    service_tier="ultrafast"
)

print(response.output_text)

Ultrafast doesn’t change what the model generates, it changes how quickly tokens arrive once generation starts, which is the metric that matters for voice agents, live captioning, or any UI where a user is staring at a blinking cursor. It’s available to every API account by default, subject to the same rate limits as standard requests, and it runs in both the US and EU data residency regions with global request routing. There’s no separate model to request and no extra approval step, it’s purely a processing-tier flag on top of the model you’re already calling.

Treat Ultrafast as one end of a four-way tradeoff rather than a feature you flip on everywhere. Standard requests sit in the middle. Flex processing trades some speed for a lower price on workloads that can tolerate it. Batch processing, covered in Step 9, cuts the price in half in exchange for asynchronous delivery within 24 hours. Reserve Ultrafast for the specific requests in your app where a user is actively waiting on a response, and leave background jobs on Standard or Batch.

Step 6: Stream Tokens in Real Time

Pairing Ultrafast mode with streaming is what actually produces the snappy, word-by-word feel users expect from a modern chat interface. Set stream=True and iterate over the returned events instead of waiting for the full object:

stream = client.responses.create(
    model="gpt-6.1-sol",
    input="List three benefits of prompt caching for a high-traffic API.",
    service_tier="ultrafast",
    stream=True
)

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

The Node.js equivalent uses an async iterator over the same stream object:

const stream = await client.responses.create({
  model: "gpt-6.1-sol",
  input: "List three benefits of prompt caching for a high-traffic API.",
  service_tier: "ultrafast",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
}

Each streamed event carries a type field you can branch on, text deltas arrive as they’re generated, and a final event marks completion with the full usage totals attached. If your frontend renders markdown, buffer deltas into whole words or sentences before rendering rather than re-parsing markdown on every single token, which avoids flickering as partial syntax briefly renders incorrectly.

Step 7: Wire Up Tools: Web Search, File Search, and Function Calling

GPT-6.1 Sol supports function calling, web search, file search, and computer-use tools natively through the Responses API, which is where the “agentic” part of agentic workflows actually lives. Function calling is the one nearly every production integration needs, since it’s how the model triggers your own code instead of just generating text.

tools = [
    {
        "type": "function",
        "name": "get_order_status",
        "description": "Look up the current status of a customer order by ID.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string"}
            },
            "required": ["order_id"]
        }
    }
]

response = client.responses.create(
    model="gpt-6.1-sol",
    input="What's the status of order A-10234?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print("Model wants to call:", item.name, "with args:", item.arguments)

When the model decides it needs the tool, it returns a function_call item instead of plain text. Your application runs the actual lookup, then sends the result back in a follow-up request referencing the same response.id so the model can incorporate it into a final answer. Enabling the built-in web search tool is even simpler, since OpenAI hosts the search infrastructure itself:

response = client.responses.create(
    model="gpt-6.1-sol",
    input="What were the most notable AI model releases this week?",
    tools=[{"type": "web_search"}]
)

print(response.output_text)

File search works the same way once you’ve uploaded documents to a vector store through the Files API, and it’s the right tool for retrieval-augmented answers over internal documentation rather than the open web. Mixing multiple tools in a single tools array is supported, and the model decides at runtime which, if any, it needs for a given input.

Step 8: Keep Multi-Turn Conversation State

Because every response is stored server-side by default, you don’t have to manually resend the entire conversation history on every call the way older Chat Completions patterns required. Pass previous_response_id and the API handles the context for you:

first = client.responses.create(
    model="gpt-6.1-sol",
    input="My name is Priya and I'm debugging a timeout in a payments service."
)

second = client.responses.create(
    model="gpt-6.1-sol",
    input="What's my name, and what was I debugging?",
    previous_response_id=first.id
)

print(second.output_text)

That second call correctly answers with Priya’s name and the payments timeout context, without you having to reconstruct and resend the first message. If you’re handling regulated data or simply don’t want conversation content retained on OpenAI’s servers, pass store=False on the request and manage history yourself on your own infrastructure instead. The tradeoff is that you lose the ability to chain calls with previous_response_id and must pass full context manually with every request.

Step 9: Cut Your Bill With Prompt Caching and the Batch API

Two cost controls matter most once you move past prototyping: automatic prompt caching and the Batch API. Caching requires no code changes at all. Once a prompt prefix of sufficient length has been sent once, OpenAI automatically serves repeated matching prefixes at the cached rate on subsequent calls, which for GPT-6.1 Sol drops the input price from $2 per million tokens to $0.10, a 95% reduction on the portion of the prompt that’s unchanged between calls.

To benefit from it consistently, structure prompts so the stable part (system instructions, few-shot examples, long reference documents) comes first and the part that changes on every call (the user’s actual question) comes last:

SYSTEM_PREFIX = """You are a support triage assistant. Classify each ticket
into one of: billing, bug_report, feature_request, account_access.
Respond with only the category name.
"""  # this long, stable block gets cached after the first call

def classify_ticket(ticket_text):
    return client.responses.create(
        model="gpt-6.1-sol",
        input=SYSTEM_PREFIX + "nTicket: " + ticket_text
    ).output_text

For anything that doesn’t need an immediate answer, like nightly report generation or bulk reclassification jobs, the Batch API is the bigger lever. It processes requests asynchronously within a 24-hour window at exactly half the standard input and output price, bringing GPT-6.1 Sol down to $1 per million input tokens and $5 per million output tokens. A batch job is submitted as a file of individual requests and polled for completion rather than returned synchronously, so it’s a fit for throughput-bound workloads, not latency-bound ones. Combining Batch with heavy prompt caching on repeated prefixes is how teams running large classification or extraction pipelines keep per-item costs close to a fraction of a cent.

Step 10: Handle Rate Limits, Errors, and Retries

Production code needs to assume calls will occasionally fail, whether from a transient network blip, a rate limit, or a malformed request on your side. Wrap calls in a retry loop with exponential backoff rather than retrying immediately in a tight loop, which only makes a rate-limit situation worse:

import time
from openai import OpenAI, RateLimitError, APIConnectionError, APIStatusError

client = OpenAI()

def call_with_retries(prompt, max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return client.responses.create(model="gpt-6.1-sol", input=prompt)
        except RateLimitError:
            wait = 2 ** attempt
            print(f"Rate limited, waiting {wait}s before retry {attempt + 1}")
            time.sleep(wait)
        except APIConnectionError:
            time.sleep(1.5)
        except APIStatusError as e:
            if e.status_code >= 500:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Exceeded max retry attempts")

This pattern catches the three error classes you’ll actually hit in practice: rate limiting (back off and retry), transient connection failures (short retry), and server-side 5xx errors (exponential backoff), while letting genuine client errors like a bad request parameter fail immediately instead of retrying something that will never succeed. Log the attempt count and wait time in production so you can see rate-limit pressure building before it starts dropping requests outright.

Step 11: Lock Down Data Residency and Storage

GPT-6.1 Sol currently supports only US and EU data residency, which matters if you’re handling data under GDPR or a contract that specifies where processing happens. Set the residency at the project level in the dashboard rather than per-request, since it’s an account-level routing decision, not a request parameter. Confirm which region a project is pinned to before sending anything containing personal data, and if your compliance requirements don’t allow server-side storage of responses at all, combine region pinning with the store=False flag from Step 8 so nothing persists beyond the request lifecycle.

It’s also worth checking this against whatever retention policy your organization already follows for other AI vendors. If you’ve been through this exercise for Claude Opus 5.5 or another provider, the same checklist of region pinning, storage opt-out, and audit logging transfers directly.

Step 12: Build a Complete Working Project: A CLI Research Assistant

Here’s everything from this tutorial combined into one runnable script: a command-line research assistant that streams its answer in Ultrafast mode, can call the web search tool when needed, retries on failure, and keeps conversation state across questions.

# research_assistant.py
import sys
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI()
MODEL = "gpt-6.1-sol"

SYSTEM_PREFIX = (
    "You are a concise technical research assistant for software engineers. "
    "Use the web_search tool when a question depends on current events or "
    "recent releases. Otherwise answer directly from your own knowledge. "
    "Keep answers under 120 words unless asked for more detail.nn"
)

def ask(prompt, previous_id=None, max_attempts=4):
    for attempt in range(max_attempts):
        try:
            stream = client.responses.create(
                model=MODEL,
                input=SYSTEM_PREFIX + prompt,
                tools=[{"type": "web_search"}],
                service_tier="ultrafast",
                previous_response_id=previous_id,
                stream=True,
            )
            full_text = ""
            response_id = None
            for event in stream:
                if event.type == "response.output_text.delta":
                    print(event.delta, end="", flush=True)
                    full_text += event.delta
                if event.type == "response.completed":
                    response_id = event.response.id
            print()
            return response_id
        except (RateLimitError, APIConnectionError):
            wait = 2 ** attempt
            print(f"n[retrying in {wait}s]", file=sys.stderr)
            time.sleep(wait)
    raise RuntimeError("Research assistant failed after retries")

if __name__ == "__main__":
    last_id = None
    print("CLI research assistant. Type 'exit' to quit.n")
    while True:
        question = input("You: ").strip()
        if question.lower() in ("exit", "quit"):
            break
        print("Assistant: ", end="")
        last_id = ask(question, previous_id=last_id)

Save that as research_assistant.py, run python3 research_assistant.py, and ask it something like “what’s new in the OpenAI Responses API this month.” You should see the answer stream in token by token, with noticeably less lag between words than a Standard-tier call, and a follow-up question like “and what model did that ship with” should correctly reference the prior answer without you repeating any context. This is the baseline pattern most production chat and agent tools are built on top of: streaming plus tools plus state plus retries, with Ultrafast mode handling the perceived latency.

Step 13: Monitor Usage and Ship to Production

Before pushing this to real users, add three things: usage logging, a spend alert, and a timeout. Every response object carries a usage block with input, output, and cached-token counts, which is enough to build a per-user or per-feature cost dashboard without calling a separate billing endpoint:

response = client.responses.create(model="gpt-6.1-sol", input=prompt)
usage = response.usage
print(f"input={usage.input_tokens} cached={usage.input_tokens_details.cached_tokens} output={usage.output_tokens}")

Pipe that into whatever logging stack you already run, set a dashboard-level spend alert in the OpenAI project settings separate from the hard cap you set in Step 1, and set a client-side timeout (10 to 15 seconds is reasonable for a Standard-tier call, shorter for Ultrafast) so a single stuck request can’t hang a user-facing request thread indefinitely. If you’re deploying this inside a serverless function, remember that cold starts add latency on top of whatever the API itself takes, so benchmark the full round trip in your actual deployment environment rather than just on your laptop.

Common Pitfalls When Migrating From Chat Completions

• Assuming message arrays still work the same way. The Responses API accepts a simple string for input in the common case, but if you’re porting a multi-message Chat Completions array, you need to restructure it into the Responses API’s input-item format rather than passing it through unchanged.
• Forgetting the SDK version gate. Older pinned versions of openai in Python or Node simply don’t recognize service_tier="ultrafast" and will throw an unexpected-keyword error. Always check your installed version against the table in the Prerequisites section before filing a bug.
• Leaving storage on by default in a regulated environment. Responses are stored server-side unless you explicitly pass store=False. Teams handling healthcare or financial data sometimes discover this only during a compliance review.
• Using Ultrafast mode everywhere. It’s priced and rate-limited the same as Standard, so there’s no cost penalty for using it broadly, but background or batch-friendly jobs gain nothing from lower inter-token latency and are better served by cheaper Batch or Flex tiers.
• Breaking prompt caching by reordering prompts. Caching matches on the stable prefix of a prompt. Putting the variable, per-request content first (common when developers prepend a timestamp or request ID) defeats caching entirely and silently restores the full $2-per-million input rate.
• Not handling the function_call item type. Developers coming from Chat Completions’ tool_calls field sometimes look for the wrong attribute name on the response object and conclude tool calling isn’t working, when it’s just a different schema.

Troubleshooting Checklist

• “Unexpected keyword argument: service_tier”: your SDK is older than 3.28.0 (Python) or 7.32.0 (Node). Run the upgrade command from Step 2.
• 401 Unauthorized on every call: the API key wasn’t exported in the shell session actually running the script, or you’re in a new terminal tab that never sourced the profile update from Step 1.
• 429 Too Many Requests: you’re hitting your project’s rate limit. Add the retry-with-backoff pattern from Step 10, or request a rate limit increase from the dashboard if you’re consistently maxing it out.
• Responses come back noticeably slower than expected even with Ultrafast set: double-check the parameter is actually service_tier and the value is the string "ultrafast", not a boolean or a different casing. A silently ignored unknown field won’t always error.
• previous_response_id “not found” errors: you likely called a prior request with store=False, which prevents chaining since nothing was retained to reference.
• Streaming callback never fires: confirm you’re checking event.type == "response.output_text.delta" exactly, since other event types for completion, tool calls, and errors pass through the same loop and get silently skipped if your condition is too narrow or misspelled.
• Function calls never resolve into a final answer: after your code executes the requested function, you must send the result back in a new responses.create call that includes the function’s output and references the original response.id. Skipping that round trip leaves the model waiting on a tool result it never receives.
• Cached input isn’t showing the discounted rate on your invoice: caching requires a sufficiently long, byte-identical prefix on a repeated call within a short time window. Minor whitespace or ordering differences between calls will break the match.
• Batch jobs stuck in “in_progress” past 24 hours: this is outside normal behavior, so check the batch status endpoint directly and contact OpenAI support with the batch ID rather than resubmitting, which will double your queued workload.

Advanced Tips for Scaling in Production

Once the basic integration is stable, a few patterns separate a prototype from something that holds up under real traffic. Route by intent rather than defaulting every call to one model: a lightweight classifier running on GPT-6 Luna can triage incoming requests and only escalate the genuinely hard ones to Sol or Astra, which can cut blended cost substantially on mixed-complexity workloads. Precompute and cache the stable system-prompt prefix across your entire fleet of workers rather than per-instance, so cold caches on a newly scaled-up server don’t eat the $2 standard rate while warming up.

For agentic pipelines that chain multiple tool calls, set a hard step limit (five to eight tool calls per conversation is a reasonable ceiling for most support or research use cases) to prevent a model from looping indefinitely on an ambiguous task and running up usage without resolving anything. And if you’re running both synchronous Ultrafast traffic and asynchronous Batch jobs against the same project, keep them on separate API keys so a batch backlog can never consume the rate-limit budget your live, user-facing Ultrafast requests depend on.

Finally, build your own thin abstraction layer over the raw SDK calls rather than scattering client.responses.create calls throughout your codebase. A single wrapper function that handles retries, logging, and model selection means a future OpenAI SDK change, or a decision to route some traffic to a different provider entirely, touches one file instead of dozens. If you’re also running local models for cost or privacy reasons, self-hosting with Ollama is worth comparing against the Luna tier for your lowest-stakes, highest-volume requests.

Run the actual numbers before you commit to a model mix. A support bot handling 50,000 tickets a month, each averaging 400 input tokens and 150 output tokens on GPT-6.1 Sol, costs roughly $40 a month in input tokens and $75 in output tokens at Standard pricing, around $115 total before caching. Route that same traffic through a cached system prompt covering 300 of those 400 input tokens per call, and the input cost drops to about $11.50, pulling the blended total closer to $87 a month. Swap the same workload to GPT-6 Astra instead and the output cost alone jumps to roughly $375, a reminder that the model-selection step in Step 4 isn’t a minor detail, it’s usually the single biggest lever on your monthly bill.

Responses API vs Chat Completions: Quick Reference

Chat Completions isn’t deprecated and existing integrations will keep working, but OpenAI’s own migration guide is explicit that the Responses API is the forward path, and new capabilities like Ultrafast mode are landing there first. If you’re starting a project today, there’s little reason to build on the older endpoint. OpenAI’s API changelog is also the fastest way to track when new service tiers or models reach your account, and the Responses API reference documents every parameter used in this tutorial in full.

For a hands-on look at how another provider structures its own agentic request format, see our Claude Opus 5.5 setup walkthrough, and browse the rest of our AI and machine learning coverage for how competing providers are shipping similar primitives.

Frequently Asked Questions

Is the OpenAI Responses API free to use?
No. It uses the same pay-per-token billing as Chat Completions. GPT-6.1 Sol costs $2 per million input tokens and $10 per million output tokens at Standard pricing, with discounted rates for cached input and Batch processing.

Do I need to rewrite my entire app to use Ultrafast mode?
No. Ultrafast mode is a single parameter, service_tier="ultrafast", added to an existing Responses API call. It requires no changes to your prompts or application logic, only an SDK version recent enough to recognize the parameter.

What’s the difference between GPT-6.1 Sol and GPT-6 Astra?
Sol is positioned as a lower-cost model that delivers performance close to Astra on complex work, priced at $2/$10 per million input/output tokens versus Astra’s $10/$50. Both share the same 1.05-million-token context window.

Can I use the Responses API with languages other than Python and Node.js?
Yes. OpenAI publishes official SDKs for several languages including Go and Java, and the API itself is a standard REST interface reachable from any language that can send an authenticated HTTPS request, as shown in the curl example in Step 3.

Is my data used to train OpenAI’s models?
OpenAI’s API data usage policies state that data submitted through the API is not used to train models by default. Responses are stored for operational purposes unless you disable this with store=False, which is a separate setting from model training.

Why does my cached input cost not show the discount?
Prompt caching requires a byte-identical, sufficiently long prompt prefix across calls made close together in time. Any change in the stable portion of your prompt, including whitespace, breaks the cache match and reverts that call to the standard input rate.

Does Ultrafast mode cost more than Standard processing?
No additional per-token surcharge is documented for Ultrafast mode beyond GPT-6.1 Sol’s standard Responses API pricing. It changes delivery speed, not the headline token price.

What happens to Chat Completions API integrations I already have?
They continue to function. OpenAI has not announced a shutdown date for Chat Completions, but is directing new feature development, including Ultrafast mode, toward the Responses API, so existing integrations will fall further behind on capabilities over time.