OpenAI

By OpenAI

OpenAI's GPT models via the API — function calling, structured outputs, and the de-facto API shape

Website ↗ Repository ↗ Docs ↗

v2.47.02026-07-22APIProprietary

#llm #function-calling #structured-output #api

31.2k Paid

Doc version 1.0 · Updated June 28, 2026

Related concepts

Harness Engineering Doc version 1.0 · Updated June 28, 2026 Wrapping an LLM in scaffolding — a control loop, tools, a sandbox, guardrails, and evaluation — so it behaves reliably in production.

Related tools

LiteLLM

Gateways & Routers

Overview

OpenAI’s API serves the GPT models and popularized the chat completions shape that most of the ecosystem now mirrors.
It has first-class function calling and structured outputs, and the broadest tooling/integration support of any provider.

Common model ids:

gpt-4o — flagship multimodal model
gpt-4o-mini — fast and cheap for high-volume work

flowchart LR
  app[your app] --> oai[OpenAI API]
  oai --> reply[reply]

The Code samples tab shows the native SDK and the LiteLLM route — pick from the selector to compare.

When to use it

Reach for OpenAI when you want broad ecosystem support and mature function calling — and route it through LiteLLM so you can swap providers later.

Pricing

Paid API billed per token; cached input and Batch are 50% off. Prices per million tokens (input / output)

Plan	Price	Notes
GPT-4o	$2.50 / $10	Flagship multimodal
GPT-4o mini	$0.15 / $0.60	Small, low-cost

Source ↗ · as of 2026-06-27

Example

Python · chat completions

When to use

Reach for the native SDK when you want OpenAI-specific features or the latest models the day they ship.

How it flows

chat.completions.create returns choices; the text is on choices[0].message.content.

Structure

flowchart LR
  app[your app] --> oai[OpenAI API]
  oai --> reply[reply]

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY

resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize OpenAI in one line."}],
)
print(resp.choices[0].message.content)

When to use

Route through LiteLLM to keep your agent provider-agnostic — the same call shape works for every provider.

How it flows

LiteLLM mirrors OpenAI's request/response, so openai/<model> is a near-passthrough.

Structure

flowchart LR
  app[your app] --> lite[LiteLLM]
  lite -->|openai/| oai[OpenAI API]

from litellm import completion

# The openai/ prefix routes to OpenAI with your OPENAI_API_KEY.
resp = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Summarize OpenAI in one line."}],
)
print(resp.choices[0].message.content)

Example

OpenAI — a minimal chat call

A real, runnable mini-project. Download it and run with Docker.

View samples/openai_1 on GitHub ↗

June 28, 2026

OpenAI — a minimal chat call

A tiny OpenAI script: it sends one prompt to a GPT model with the official SDK and prints the reply.

Configure

cd samples/openai_1
cp .env.sample .env
# edit .env: set OPENAI_API_KEY (and optionally MODEL)

Get a key at platform.openai.com/api-keys. MODEL defaults to gpt-4o. .env is gitignored — only .env.sample is committed.

Run with Docker

cd samples/openai_1
docker build -t aas-openai .
docker run --rm --env-file .env aas-openai "Summarize OpenAI's API in one sentence."

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The script runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. You can confirm this: docker logs on the same container shows the full output, the container exits 0, and it is not an OOM. Run detached and follow the logs instead:

cd samples/openai_1
docker build -t aas-openai .
docker logs -f "$(docker run -d --env-file .env aas-openai \
  "Summarize OpenAI's API in one sentence.")"

Run locally

cd samples/openai_1
pip install -r requirements.txt
python app.py "Summarize OpenAI's API in one sentence."

python-dotenv loads .env automatically.

Example run

Output varies by model and run — LLMs are non-deterministic, so the wording differs each time. Below is one run with gpt-4o.

OpenAI's API provides developers with access to advanced AI models for natural
language processing, enabling tasks like text generation, editing, and
understanding, as well as other capabilities such as image and code analysis.

Files

.env.sample

# Copy this file to `.env` and add your OpenAI API key.
#   cp .env.sample .env
#
# Get a key at https://platform.openai.com/api-keys
OPENAI_API_KEY=

# Model id — see https://platform.openai.com/docs/models
MODEL=gpt-4o

app.py

"""OpenAI: a minimal chat call with the official SDK.

Sends one prompt to a GPT model and prints the reply. The point is the smallest
real call — `chat.completions.create` — that most of the ecosystem mirrors.

Run:
    docker build -t aas-openai .
    docker run --rm --env-file .env aas-openai "Summarize OpenAI in one line."
"""

import os
import sys

from dotenv import load_dotenv
from openai import OpenAI

# Load .env when running locally; in Docker the key comes from --env-file.
load_dotenv()

client = OpenAI()  # reads OPENAI_API_KEY
MODEL = os.environ.get("MODEL", "gpt-4o")


def main() -> None:
    prompt = " ".join(sys.argv[1:]) or "Summarize what OpenAI's API offers in one sentence."

    resp = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
    )
    print(resp.choices[0].message.content)


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the OpenAI sample.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-openai "<prompt>"
ENTRYPOINT ["python", "app.py"]