GPT 5.6 Luna

gpt-5.6-luna

GPT-5.6 Luna is the fast, cost-efficient model in the OpenAI GPT-5.6 series. It is suited for high-volume, latency-sensitive tasks such as chat, classification, and lightweight agent workflows, delivering strong reasoning at its price tier.

Context window1.0M

ProviderOpenAI

Released2026/07/10

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 context	Input	Output	Cache read	Cache write
≤ 272K	0.20/M	1.20/M	0.02/M	0.25/M
> 272K	0.40/M	1.80/M	0.04/M	0.50/M

5% off

Preferred

A balanced route optimized for availability and speed — a good default for production traffic.

Input context	Input	Output	Cache read	Cache write
≤ 272K	0.200.19/M	1.201.14/M	0.020.02/M	0.250.24/M
> 272K	0.400.38/M	1.801.71/M	0.040.04/M	0.500.47/M

Overview

Input

Text Image

Output

Text

GPT-5.6 Luna API: High-Throughput, Low-Latency Economy Tier

GPT-5.6 Luna is the fastest and most economical model in the OpenAI GPT-5.6 series. It is designed for high-volume, latency-sensitive tasks—chat, classification, information extraction, and lightweight agent workflows—and delivers solid reasoning capabilities at this price tier.

Luna scores 74.6 on the Artificial Analysis Coding Agent Index, not far behind Terra's 77.4 in the balanced tier, but with clear advantages in throughput and cost. For scenarios running millions of calls per day, Luna is often the only choice that makes economic sense.

SeaWhale AI offers GPT-5.6 Luna through an OpenAI-compatible interface, supporting tool calling, streaming output, and multimodal input.

Get API Key · Model ID: gpt-5.6-luna

Why Choose GPT-5.6 Luna

Fastest, most affordable tier in the series — designed for large-scale, latency-sensitive production traffic
Solid reasoning within its price tier — Coding Agent Index 74.6, not just a "small model"
1 million token context — the economy tier also supports ultra-long context input
256K output limit — batch-generate long content without restrictions
Fully interchangeable with Terra / Sol — just change the model ID when you need stronger capabilities

Core Capabilities

01 High-Volume, Low-Latency Tasks

Luna is positioned to put AI on high-frequency paths: real-time chat, content moderation, intent recognition, and log analysis. It responds quickly and costs little, so you can confidently call it on every request.

Real-time chat and conversational products
Intent recognition and content classification
High-concurrency batch processing pipelines

02 Information Extraction and Structured Output

Extracting fields from unstructured text and generating structured JSON is one of the scenarios Luna is best suited for. Combined with tool calling and a strict schema, it can be reliably integrated into downstream systems.

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

03 Lightweight Agents and Subtasks

In multi-agent architectures, Luna is well suited to the sub-agent role: executing subtasks such as search, reading, and filtering in parallel, then handing results to a stronger model for aggregation.

Parallel sub-agent execution
Preliminary filtering and ranking of retrieval results
Simple tool-calling loops

04 1-Million-Token Long Context

The economy tier also supports a 1-million-token context window, making it possible to process entire documents and long conversation histories at low cost.

Long-document summarization and Q&A
Long conversation history compression
Large-scale corpus preprocessing

Best Use Cases

Scenario	Description
Real-time conversation products	Latency-sensitive customer service, assistants, and chatbots
Content classification and moderation	High-frequency intent recognition, tagging, and compliance checks
Information extraction	Generate structured data from unstructured text
Batch processing pipelines	Large-scale corpus cleaning, annotation, and transformation
Sub-agents	Parallel execution units in multi-agent architectures
Long-document preprocessing	Low-cost summarization within a 1-million-token window

GPT-5.6 Luna vs. Terra and Sol

Capability	GPT-5.6 Luna	GPT-5.6 Terra	GPT-5.6 Sol
Model ID	`gpt-5.6-luna`	`gpt-5.6-terra`	`gpt-5.6-sol`
Positioning	Fastest, most affordable	Balanced everyday workhorse	Flagship frontier model
Coding Agent Index	74.6	77.4	80
Context window	1 million tokens	100K tokens	100K tokens
Max output	256K tokens	256K tokens	256K tokens
Best for	Extraction, classification, batch processing	Coding, analysis, copilots	Complex agents, safety, science

For specific billing, refer to the real-time price card at the top of the page.

FAQ

Is Luna capable enough? For tasks like classification, extraction, summarization, and simple conversation, it is more than sufficient. The Coding Agent Index of 74.6 also shows that it is not a small model that "can only do simple work." Upgrade to Terra when you need multi-step planning and deep reasoning.

How do I choose between Luna and Terra? It depends on task complexity. Use Luna for high-frequency, repeatable, well-structured tasks; use Terra for tasks that require real reasoning and planning. The two share the same interface, so you can switch dynamically at runtime.

How large is the context window? 1 million tokens. It's the largest context window among the three GPT-5.6 tiers, suitable for long-document preprocessing scenarios.

Does it support tool calling? Yes. Function calling, streaming output, and image input are all available, making it suitable as a sub-agent in multi-agent architectures.

Is it suitable for batch processing? Very much so. High throughput and low unit price are Luna's core advantages, and it is the most cost-effective choice for large-scale offline tasks.

How can I use it with other models? On SeaWhale AI, you can call all models with the same API key and route requests to Luna / Terra / Sol or models from other vendors based on request complexity.

Why Choose SeaWhale AI for GPT-5.6 Luna API

Cost-optimization friendly — shares the same interface as higher tiers, making it easy to upgrade or downgrade on demand
OpenAI compatible — integrate by changing just two lines in your existing code
Stable under high concurrency — the platform handles large-scale calls, so there's no need to build your own proxy
Unified usage dashboard — view call volume and spend across models in one place

API

API integration

Model IDUse this value as the model in inference requests

gpt-5.6-luna

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.6-luna 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.6-luna",
    "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.6-luna",
    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.6-luna',
  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 ?? '')
}