OpenAI Agents SDK Pricing: Responses API Cost for Agents

An OpenAI agent costs between four cents and about a dollar per 12-step run depending on the model, and the SDK adds nothing. The Agents SDK (Agent, Runner) is an open-source orchestration layer over the Responses API; you pay the token rates of whichever model the agent uses. Using a 4,000-token system prompt plus tool schemas, 1,500-token tool results and 300 output tokens per step (166,800 input tokens and 3,600 output tokens over 12 steps), uncached run costs are:

Prices are USD per 1M tokens from our catalogue dated 2026-09-11. For GPT-5.4: 166,800 × $2.50 ÷ 1,000,000 = $0.417 input, plus 3,600 × $15 ÷ 1,000,000 = $0.054 output, total $0.471. GPT-5.5 Pro at 12× the GPT-5.4 rate belongs to one-shot hard problems, not loops.

A Responses API agent turn is client.responses.create with tools=[...] and input=[...]. The model returns function_call items; you run them, append function_call_output items and call again. Every call bills the full input list, so the twelfth call in the trace sends 23,800 tokens and the run sends 166,800.

Two Responses-specific mechanics change what you pay. previous_response_id stores the conversation server-side so you only send new items; this is a convenience, not a discount, because the stored context is still billed as input each turn. What it does do is keep your prefix byte-identical, which is what makes automatic caching fire. And reasoning tokens bill as output: GPT-5.5 and GPT-5.4 reason by default, so set reasoning={"effort": "low"} on worker agents that only need to pick a tool. Output is 11% of the GPT-5.4 run; input, nearly all of it repeated context, is the other 89%.

OpenAI applies prompt caching automatically to any request whose prefix matches a recent request, with cached input tokens billed at roughly 10% of the list input rate. There is no cache_control block to add; the work is keeping the prefix stable. Put the system prompt and tool definitions first, never re-order tools between calls, and keep timestamps and request IDs out of the prefix.

On the 12-step trace, caching brings GPT-5.4 from $0.471 to roughly $0.15 and GPT-5.4 mini from $0.141 to roughly $0.045. On a 30-step run (903,000 input tokens uncached) GPT-5.4 drops from $2.39 to roughly $0.49. Verify by reading usage.input_tokens_details.cached_tokens; if it stays at zero after the first step, something in the prefix is moving.

from openai import OpenAI

client = OpenAI()
tools = [{
    "type": "function", "name": "lookup_invoice", "strict": True,
    "description": "Fetch an invoice by number",
    "parameters": {"type": "object", "properties": {"number": {"type": "string"}},
                   "required": ["number"], "additionalProperties": False},
}]
resp = client.responses.create(
    model="gpt-5.4",
    instructions=SYSTEM_PROMPT,          # stable prefix: instructions + tools
    tools=tools,
    input=history,                       # growing list of items
    reasoning={"effort": "low"},
    max_output_tokens=2000,
)
u = resp.usage
cached = u.input_tokens_details.cached_tokens
# GPT-5.4: $2.50 in, ~$0.25 cached in, $15 out per 1M
cost = ((u.input_tokens - cached) * 2.5 + cached * 0.25
        + u.output_tokens * 15) / 1_000_000

The prompt caching cost comparison sets this beside Anthropic's explicit cache_control and Gemini's context caching.

The Agents SDK runs the loop for you: Runner.run calls the model, executes your @function_tool functions, appends results and repeats until the agent returns a final output or hits max_turns. It costs nothing extra but changes two things about spend. max_turns (default 10) is your step cap; set it deliberately. And handoffs carry the conversation into each new agent's context, which raises the input bill without making it obvious.

from agents import Agent, Runner, function_tool

@function_tool
def lookup_invoice(number: str) -> str:
    return db.invoice(number)

agent = Agent(name="billing", model="gpt-5.4-mini",
              instructions=SYSTEM_PROMPT, tools=[lookup_invoice])
result = Runner.run_sync(agent, task, max_turns=12)
usage = result.context_wrapper.usage
# GPT-5.4 mini: $0.75 in / $4.50 out per 1M; 12 reference steps ~= $0.14
run_cost = (usage.input_tokens * 0.75 + usage.output_tokens * 4.5) / 1_000_000

Built-in hosted tools (web search, file search, code interpreter, computer use) are billed separately from tokens at per-use rates that are not in our catalogue, so check the vendor pricing page before enabling them. The content they return is then billed as normal input on every later step.

The cheapest model that still does this reliably: GPT-5.4 mini at $0.141 per 12-step run (roughly $0.045 cached). With strict: True on every function it follows schemas consistently, its 400K context covers any sane loop, and it costs 30% of GPT-5.4. It is our default for worker agents and for any loop whose tool calls are validated before execution.

GPT-5.4 nano at $0.038 per run is a third of mini again. Use it for classification-and-route steps, extraction and tool selection over a small tool set where a wrong call is cheap to catch. Do not make it the planner: when nano wanders it wanders for many steps, and 30 nano steps ($0.19) cost more than 12 mini steps.

GPT-5.3-Codex at $1.75/$14 ($0.342 per run) is the coding specialist. For agents that write and edit code it tends to finish in fewer steps than GPT-5.4 mini, which is the only reason to pay 2.4× more per step.

When to pay for the flagship: GPT-5.4 ($0.471) for open-ended tasks and anything with side effects; GPT-5.5 ($0.942) only as the planner in a multi-agent setup or where a single failed run costs more than about a dollar. GPT-5.5 is exactly 2× GPT-5.4 per run and must halve the failure rate or the step count to break even. The cheapest LLM for agents guide ranks all of these against Anthropic, Google and open-weight models on the same trace.

ChatGPT plans do not include API credit. ChatGPT Plus ($20), Pro ($200) and Business ($25 per seat) buy a person access to ChatGPT and the Codex agent inside it, with usage allowances rather than a token meter, so the comparison only holds for a human driving an agent interactively.

A developer using Codex for a few coding tasks a day is well inside what Plus or Business covers, and Business adds admin controls and keeps workspace data out of training by default. Pro at $200 only makes sense for someone whose interactive use would otherwise exceed roughly 400 flagship runs a month. Our ChatGPT pricing and OpenAI Codex pricing pages have the plan details.

The API wins for anything unattended, parallel, or embedded in a product, and on price the moment routine steps go to mini or nano: 1,000 cached GPT-5.4 mini runs cost about $45, which no seat plan can back.

Apply all four; each catches a different failure:

• max_output_tokens per call: 1,000 to 4,000 for tool-calling turns. This caps one turn, including reasoning tokens.
• max_turns on Runner.run, or a manual step counter: 12 to 15 for most task types.
• Stop conditions: a required finish function, an abort on two identical consecutive function calls, and an abort on a tool error repeated twice.
• A per-run USD budget computed from usage after each call, with cached tokens at roughly 10% of list. Abort past your ceiling and record the total per task to compute cost per successful task.

At GPT-5.4 rates a $0.50 per-run budget covers about 12 uncached reference steps or roughly 35 cached. For fan-out work that can wait, the Batch API runs at roughly 50% of list; it cannot run a live loop but can run 10,000 short agents overnight. See LLM batch API pricing and the AI cost calculator for monthly budgets.

What it costs: $0.04 to $0.94 per 12-step run across the GPT-5 range before caching, roughly $0.01 to $0.30 after. Who should pay API rates: anyone running agents unattended, at volume, or in a product, with routine steps on GPT-5.4 mini or nano. Who should not: an individual developer using Codex interactively, for whom Plus or Business at $20 to $25 beats any plausible API bill. Cheapest way to get the result: GPT-5.4 mini with strict schemas and a stable cached prefix, GPT-5.4 for open-ended or side-effecting steps, GPT-5.5 as an occasional planner, max_turns set on purpose. See the Claude agent API cost and Gemini agent API cost guides for the other stacks, how much does an AI agent cost to run for the trace, and the ChatGPT 101 tutorial for API basics.