GPT-5.4 Nano

gpt-5.4-nano

GPT-5.4 nano is the lightest-weight and most cost-effective variant in the GPT-5.4 series, optimized for speed-critical and high-volume tasks. It supports text and image inputs and is designed for low-latency use cases such as classification, data extraction, ranking, and sub-agent execution. The model prioritizes responsiveness and efficiency over deep reasoning, making it an ideal choice for pipelines that require fast, reliable output at scale. GPT-5.4 nano is well-suited for background tasks, real-time systems, and distributed agent architectures where minimizing cost and latency is critical.

Context window400K

ProviderOpenAI

Released2026/04/12

Playground

Pricing

The same model is available through multiple service channels — choose based on latency, reliability and cost.

Prices in $ / 1M tokens

To pick a channel, add a provider field to the request body, for example "provider": { "channel": "direct" }. Valid values are direct / stable / economical; omit it to use the default channel.

Direct

Direct upstream connection — best when you need native behavior and the full context window.

Input	Output	Cache read
0.20/M	1.25/M	0.02/M

Overview

Input

Text Image

Output

Text

GPT-5.4 Nano API: The Ultra-Lightweight Tier for Speed-Critical Scenarios

GPT-5.4 Nano is the lightest and most cost-effective variant in the GPT-5.4 series, optimized for speed-critical and high-volume tasks. It supports text and image input and is designed for low-latency use cases — classification, data extraction, ranking, and sub-agent execution.

Nano's design trade-off is clear: it prioritizes response speed and efficiency over deep reasoning. This makes it an ideal choice for pipelines that require large-scale, fast, reliable output, and it is particularly well suited to handling parallel subtasks in multi-agent architectures.

SeaWhale AI offers GPT-5.4 Nano through an OpenAI-compatible interface, with support for tool calling, streaming output, and image input.

Get API Key · Model ID: gpt-5.4-nano

Why Choose GPT-5.4 Nano

The most economical tier in the GPT-5.4 series — a powerful cost-control tool for high-frequency call scenarios
Ultra-low latency — built for real-time responses and high-concurrency pipelines
400K-token context — the lightweight tier also supports long-context input
128K output limit — batch generation without constraints
Image input support — the lightweight tier can also handle basic vision tasks

Core Capabilities

01 Classification and Intent Recognition

Nano's most typical use case is high-frequency discriminative tasks: classifying inputs into a limited set of categories. These tasks don't require deep reasoning; they need stability, speed, and low cost.

Customer service ticket classification and routing
Content moderation and compliance labeling
User intent recognition

02 Data Extraction and Structuring

Extract fields from unstructured text and output structured results; combined with tool calling, it can directly connect to downstream systems.

Field extraction from forms, receipts, and resumes
Structured JSON output
Data cleaning and format standardization

03 Ranking and Filtering

In retrieval-augmented (RAG) pipelines, Nano is suitable for re-ranking recall results and relevance filtering, passing the most relevant few pieces of content to a stronger model.

Re-ranking of retrieval results
Relevance scoring and initial filtering
Candidate set trimming

04 Sub-Agent Execution

In multi-agent architectures, Nano can execute a large number of parallel read, search, and check subtasks, aggregate the results back to the main agent, and significantly reduce overall cost.

Parallel subtask execution
Execution layer for tool calls
Large-scale fan-out operations

Best Use Scenarios

Scenario	Description
High-frequency classification	Ticket routing, content moderation, intent recognition
Information extraction	Converting unstructured text into structured data
RAG re-ranking	Relevance scoring and filtering of retrieval results
Sub-agent	Parallel execution units in multi-agent architectures
Batch processing pipelines	Large-scale corpus cleaning, labeling, and transformation
Real-time response	Interaction scenarios extremely sensitive to latency

Differences Between GPT-5.4 Nano and Other Lightweight Tiers

Capability	GPT-5.4 Nano	GPT-5.6 Luna	GPT-5.4 Mini
Model ID	`gpt-5.4-nano`	`gpt-5.6-luna`	`gpt-5.4-mini`
Positioning	Ultra-lightweight, speed-first	Next-generation economy tier	Lightweight balanced tier
Context window	400K tokens	1M tokens	Smaller
Max output	128K tokens	256K tokens	Smaller
Reasoning depth	Shallow (speed-first)	Medium	Medium
Best for	Classification, extraction, ranking	Extraction, batch processing, lightweight agents	General lightweight tasks

Actual billing is based on the real-time price card at the top of the page.

How to Use the GPT-5.4 Nano API

1. Create a SeaWhale AI API key Generate a key in the console and top up your balance.

2. Make your prompts as deterministic as possible Nano prioritizes speed; the more specific the prompt and the clearer the output format constraints, the more stable the results. Avoid asking it to perform open-ended reasoning.

3. Call the API

curl -X POST https://api.atalk-ai.com/v1/chat/completions \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gpt-5.4-nano",
    "messages": [
      {"role": "system", "content": "Output only one category, without explanation. Available categories: inquiry, complaint, refund, other."},
      {"role": "user", "content": "I bought something last week and it still hasn't shipped. Can I get a refund?"}
    ]
  }'

Frequently Asked Questions

Can Nano handle reasoning tasks? Not recommended. Nano's design goal is speed and cost; for deep reasoning, please use GPT-5.5, GPT-5.6 Terra, or a higher tier.

How do I choose between Nano and GPT-5.6 Luna? Luna is a next-generation economy tier with a larger context window and output limit, and stronger overall capabilities; Nano is more extremely skewed toward speed and cost. Choose Nano for scenarios that are extremely latency-sensitive or have very high call volume.

How large is the context window? 400K tokens, which is quite ample for a lightweight tier and can even handle long-document summarization.

Does it support image input? Yes. It can do basic image classification and information extraction; for complex visual reasoning, please use a stronger tier.

Is it suitable for sub-agents? Very suitable. Using Nano for parallel subtasks in multi-agent architectures is a common practice for keeping overall costs down.

How can output stability be ensured? Using system prompts to explicitly constrain the output format, or combining them with strict schemas in tool calls, can significantly improve the stability of structured output.

Why Choose SeaWhale AI for GPT-5.4 Nano API

Cost-optimized foundation layer — share the same API key with stronger models to build a tiered routing architecture
OpenAI-compatible — integrate with existing code by changing just two lines
High-concurrency capacity — the platform handles large-scale calls, no need to build your own proxy
Unified usage dashboard — centrally view call volume and spend across models

API

API integration

Model IDUse this value as the model in inference requests

gpt-5.4-nano

API KeyBearer token used to authenticate inference requests

Manage API keys

Base URLOpenAI compatible · /chat/completions

https://api.atalk-ai.com/v2/

provider OptionalSelects a service channel; omit it and the system picks the default

"provider": { "channel": "direct" }

gpt-5.4-nano usage examples

SeaWhale AI is compatible with the OpenAI API protocol, so you can call it with the OpenAI SDK or plain HTTP requests. Streaming is enabled by default.

About the provider parameter (optional, a SeaWhale AI extension): most models are served over several channels that differ slightly in price and reliability. Add a provider field to the request body to pick one; omit it and the system selects the default channel — normal calls are unaffected.

provider is not part of the official OpenAI protocol — it is a SeaWhale AI extension that only takes effect on this platform. The OpenAI SDK allows custom fields like this to pass through; see the examples below.

Value	Channel	Best for
`direct`	Direct	The official upstream link, for native behavior and the full context window
`stable`	Preferred	Balanced availability and speed — a good default for production traffic
`economical`	Economy	Cost first, well suited to batch processing and price-sensitive workloads

Available channels and their prices are listed under "Pricing" above (channels vary by model). Additional notes:

Syntax: "provider": { "channel": "direct" }.
If the requested channel is not enabled for that model, the request automatically falls back to the default channel and returns normally — it does not error.
With the official SDKs: in Python pass it via extra_body; in Node.js put it directly on the request object and it passes through. In TypeScript projects, add a // @ts-expect-error line to skip the type check.

cURLPythonNode.js

curl https://api.atalk-ai.com/v2/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API_KEY>" \
  -d '{
    "model": "gpt-5.4-nano",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "provider": { "channel": "direct" },
    "stream": true
  }'
# provider is optional — remove this line to use the default channel

from openai import OpenAI

client = OpenAI(
    base_url="https://api.atalk-ai.com/v2",
    api_key="<API_KEY>",
)

stream = client.chat.completions.create(
    model="gpt-5.4-nano",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"},
    ],
    stream=True,
    # Optional: pick a service channel; omit to use the default
    extra_body={"provider": {"channel": "direct"}},
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: 'https://api.atalk-ai.com/v2',
  apiKey: '<API_KEY>',
})

const stream = await client.chat.completions.create({
  model: 'gpt-5.4-nano',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello!' },
  ],
  stream: true,
  // Optional: pick a service channel; omit to use the default
  // @ts-expect-error provider is a SeaWhale AI extension, not in the OpenAI SDK types
  provider: { channel: 'direct' },
})

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '')
}