What is the OpenAI Platform?

What it is

The OpenAI Platform is the developer side of OpenAI - the infrastructure for putting its models inside software you ship rather than a chat window you open. Your code sends a structured request and gets a structured response back, with control over which model answers, how hard it reasons, which tools it may call, and what instructions it follows.

It is made of four pieces:

A REST API, centred on the Responses API, callable from any language.
Client SDKs in Python (openai) and TypeScript, plus the higher-level Agents SDK (openai-agents) for multi-step work.
Command-line and coding tools - Codex, OpenAI's coding agent, is the one most developers have met.
The dashboard at platform.openai.com: the account and admin surface - projects, keys, usage, logs, and a playground. Also the home of evals and fine-tuning.

The word to hold on to is platform, not API. The API is one call. The Platform is everything that makes a thousand of those calls behave in production - and, as with Anthropic's equivalent, that is where most of the product lives.

Not the app

ChatGPT and its Plus, Pro, Business, and Enterprise plans are a subscription for people; the Platform is an account for software, and it is the only one of the two that issues an API key. The two share a sign-in and almost nothing else - OpenAI's boundary is a wall, where Anthropic's has doors. Seats versus tokens, projects and keys, and what does not carry across are the subject of ChatGPT Business vs OpenAI Platform. This article stays on the Platform side and asks the other question: once you have the key, what is it for?

The three layers

OpenAI does not publish a layer diagram the way Anthropic does, but the same three-layer picture fits its Platform well, and it explains why the dashboard is organised the way it is.

01 · PRIMITIVES

Build with primitives

The Responses API, function calling, structured outputs, files, and the hosted tools: web search, file search, code interpreter, computer use, image generation, remote MCP servers. The Realtime API for voice sits beside them. These are the pieces your code calls.

02 · INFRASTRUCTURE

Scale on infrastructure

What you need past a prototype: the Agents SDK harness, sandbox execution, conversation state, prompt caching, the Batch API for asynchronous work at a discount, and tracing for every agent run.

03 · CONTROLS

Run with control

The dials a team uses once it is live: evals, fine-tuning, request logs, and the project-level limits and usage tiers described on the account side in ChatGPT Business vs OpenAI Platform. This is most of what platform.openai.com shows you.

Most first projects live entirely in layer one. Most production incidents are about layers two and three - and most surprise invoices are about layer three not having been set up.

A single call

Everything on the Platform reduces to one operation: responses.create. Take the same help-desk example used in the Claude article - a button that drafts a reply from a ticket, following the team's tone guide. The whole integration is one request:

            PYTHON
            draft_reply.py
          

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-luna",        # a simple drafting task: use the small model
    instructions=TONE_AND_GUIDELINES,
    input=ticket_content,
    max_output_tokens=1024,
)

draft = response.output_text
          

Each parameter does one job, and together they are the vocabulary of the whole Platform:

model - which model handles the request. Cost, speed, and capability all follow from this one line (section 08).
instructions - the system-level role. Tone, guidelines, and constraints go here, not in the input.
input - the work: a string, or a list of typed items (text, images, files, prior tool results) when the request is more than one turn.
max_output_tokens - a hard cap on the length, and therefore the cost, of the answer.

Two things distinguish this from the older Chat Completions shape. The Responses API is stateful - pass previous_response_id and the model continues the conversation without you resending the history - and it carries reasoning items between tool calls, which is why OpenAI tells you to use it for anything agentic. Chat Completions still works; the Assistants API, its predecessor for tools and threads, is sunset in 2026 and everything new goes through Responses.

The agent loop

A single call returns a single response. To automate a workflow, the model has to act, look at the result, decide what is next, and keep going. On OpenAI's Platform that loop can be written by hand, exactly as on Anthropic's:

1 · SEND

Request with tools

Call responses.create with a tools array. A function tool has a name, a description, and a JSON schema for its parameters.

2 · DECIDE

The model answers or asks

The output either contains a message (final) or one or more function_call items naming a tool and its arguments.

3 · EXECUTE

Your code runs it

You execute the function - a query, an API call, a shell command. The model never runs your code; it only asks.

4 · RETURN

Feed the result back

Send a function_call_output item in the next request (with previous_response_id) and repeat until the output is a plain message.

The shape is identical to the loop in What is the Claude Platform?; only the item names differ. The difference in kind comes one step later: the hosted tools in section 06 run inside the same call, so for web search or code execution there is no round-trip through your code at all.

You own the loop and the functions. The model owns the reasoning.- the same division of labour, either vendor

Extending an agent

The functions above were yours. The Platform also provides tools that run on OpenAI's side, switched on per request, with no server of yours involved:

Web search - live, cited answers from the web.
File search - retrieval over documents you have uploaded to a vector store, with metadata filtering.
Code interpreter - Python in a sandbox, for analysis, charts, and file transforms.
Computer use - a model that drives a browser or desktop by looking at screenshots and issuing clicks and keystrokes.
Image generation - the GPT Image models, callable as a tool inside a text conversation.
Remote MCP servers - point the request at a Model Context Protocol server and its tools become available without writing a schema for each one.

Hosted tools bill per call on top of tokens, which is worth knowing before an agent decides to search the web forty times. How function calling, MCP, and skills relate to one another, vendor-neutrally, is the subject of Functions, MCP, and Skills.

The Agents SDK

Where Anthropic offers Managed Agents - a hosted loop - OpenAI's answer is a framework you run yourself: the Agents SDK, open source, in Python and TypeScript. It wraps the Responses API in a small set of primitives and a harness that runs the loop, and since April 2026 it also gives agents a computer to work in.

Agents	A model plus instructions, tools, and settings; `Runner.run(agent, input)` executes the loop until there is a final output
Tools	Any Python or TypeScript function, decorated, becomes a schema-aware tool; hosted tools and MCP servers plug in the same way
Handoffs	One agent delegating to another - a triage agent routing to specialists is the canonical shape
Guardrails	Validators that run on input before the model sees it and on output before the user does
Sandboxes	Agents that read and write files, install packages, and run commands inside a container - bring your own, or use the built-in providers (E2B, Modal, Cloudflare, Vercel, Daytona, and others)
Manifests	A portable description of the agent's workspace: local files, output folders, and data mounted from S3, GCS, Azure Blob, or R2
Tracing	Every run records its model calls, tool invocations, and handoffs, viewable in the dashboard

The design choice worth noticing is where the harness runs. OpenAI keeps it in your process and separates it from the sandbox compute, so credentials stay out of the environment where model-written code executes, and a lost container does not mean a lost run - the SDK snapshots state and rehydrates it in a fresh sandbox. The trade against Anthropic's hosted model is the usual one: you get control over where agents run and what they can reach; you also own the servers. The SDK is provider-agnostic too, and will drive non-OpenAI models, which is unusual for a first-party framework.

Choosing a model

The model parameter is the biggest lever on cost and latency, and OpenAI's catalogue is wider than Anthropic's, which makes the choice harder rather than easier. The current headline tiers are GPT-6 Astra (gpt-6-astra) for the hardest reasoning and coding, GPT-5.6 Sol as the flagship for professional work, GPT-5.6 Terra to balance intelligence and cost, and GPT-5.6 Luna for high-volume, cost-sensitive work - a fifty-fold spread in input price from Luna to Astra. Codex variants for coding and purpose-built models for images, realtime voice, transcription, and embeddings sit beside them. Names and prices move often; the advice does not:

Do not guess; evaluate. Run a handful of your real examples through two or three models and compare quality against cost and time. The playground and the evals dashboard exist for exactly this.
Set reasoning effort deliberately. Current models expose reasoning.effort from none up to max. Start at medium and move in the direction the evaluation tells you; effort is tokens, and tokens are the bill.
Pin a snapshot in production. An alias like gpt-5.6 moves to the newest version underneath you; dated snapshots do not. Prototype on the alias, ship on the snapshot.
Budget the loop, not the call. An agent that takes twenty turns pays twenty times, plus tool fees. Per-project spend limits are how that variance stays predictable - the same problem as What an agent actually costs.

Getting started

You need three things: an account at platform.openai.com, an API key created inside a project there, and prepaid credit or a card on file. How projects, keys, and limits fit together is the account side, covered in ChatGPT Business vs OpenAI Platform. The key goes in an environment variable, the SDK reads it, and the first call is the five lines at the top of this article.

            SHELL
            terminal
          

# 1. install the SDK
pip install openai                 # or: npm install openai
pip install openai-agents          # when a single call stops being enough

# 2. the key comes from a project in the dashboard, never from ChatGPT
export OPENAI_API_KEY=sk-...

# 3. one responses.create call, then build the loop
          

The developer documentation at developers.openai.com is the reference. If you have already read the Claude version of this article, the fastest route is to translate: messages.create is responses.create, workspaces are projects, Managed Agents is the Agents SDK plus a sandbox provider, and the Console is the dashboard. The loop is the same loop.