GPT 5.6 Terra

gpt-5.6-terra

GPT-5.6 Terra is the balanced model in the OpenAI GPT-5.6 series, positioned between the flagship Sol tier and the cost-efficient Luna tier. It is suited for everyday coding, reasoning, and agentic tasks that require a balance of capability and cost, delivering robust performance at roughly half the cost of Sol.

Context window100K

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	2.00/M	12.00/M	0.20/M	2.50/M
> 272K	4.00/M	18.00/M	0.40/M	5.00/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	2.001.90/M	12.0011.40/M	0.200.19/M	2.502.38/M
> 272K	4.003.80/M	18.0017.10/M	0.400.38/M	5.004.75/M

Overview

Input

Text Image

Output

Text

GPT-5.6 Terra API: The Balanced Mainstay Tier of the GPT-5.6 Series

GPT-5.6 Terra is the balanced model in the OpenAI GPT-5.6 series, positioned between the flagship Sol and the economical Luna. It is suited for everyday coding, reasoning, and agent tasks that need a balance between capability and cost, delivering near-flagship performance at roughly half the cost of Sol.

On the Artificial Analysis Coding Agent Index, Terra scores 77.4 — not far behind Sol's 80, but at a significantly lower cost. For the vast majority of production workloads, Terra is the best value-for-money default choice in the GPT-5.6 series.

SeaWhale AI provides GPT-5.6 Terra through an OpenAI-compatible interface, supporting tool calling, reasoning effort control, streaming output, and multimodal input.

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

Why Choose GPT-5.6 Terra

The default tier in the series — Best capability/cost ratio for most production workloads
Near-flagship coding capability — Coding Agent Index 77.4, with a limited gap to Sol
256K output limit — Long-form code generation and report writing in a single pass
Fully isomorphic with Sol / Luna — Switching tiers only requires changing the model ID, zero code changes
Multimodal input — Supports text and images, covering real-world engineering scenarios

Core Capabilities

01 Everyday Coding & Copilot Scenarios

Terra is a suitable mainstay tier for coding assistants, code review, and refactoring tools. It understands cross-file dependencies, generates usable implementations, and remains stable in tool-calling loops, all while keeping costs at a level that can scale broadly.

Code completion, refactoring, and review
Cross-file feature implementation
IDE and CLI coding assistants

02 Balanced Agent Workflows

For multi-step tool-calling tasks, Terra's planning and execution capabilities are sufficient to support the majority of business automation, without paying flagship-tier prices.

Multi-step planning and tool orchestration
Function calling and parallel tool execution
Intermediate result verification and path adjustment

03 Analysis & Knowledge Work

In knowledge-work scenarios such as document processing, data analysis, and research briefings, Terra keeps per-call costs low while maintaining structural accuracy.

Long-document summarization and structured extraction
Data analysis and report generation
Presentation and table production

04 The Middle Layer of Tiered Routing

In value-based routing architectures, Terra handles the vast majority of requests: simple tasks are pushed down to Luna, truly difficult ones are escalated to Sol, and everything in between goes to Terra.

All three tiers share the same interface and account
Dynamic routing by request complexity
Significantly reduces overall inference costs

Best Use Cases

Scenario	Description
Production-grade coding assistant	Code completion, refactoring, and review at scale
Agent copilot	Multi-step tool calling and business process automation
Document and data analysis	Long-document summarization, structured extraction, report generation
Customer service and conversational products	Multi-turn dialogue balancing quality and latency
Content generation	Long-form copy, technical documentation, marketing materials
Middle layer of tiered routing	Handles most requests, sending only the hardest tasks to Sol

GPT-5.6 Terra vs. Sol and Luna

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 mainstay	Flagship frontier model
Coding Agent Index	74.6	77.4	80
Max output	256K tokens	256K tokens	256K tokens
Input modalities	Text, image	Text, image	Text, image
Best for	Extraction, classification, batch processing	Coding, analysis, copilots	Complex agents, safety, science

See the real-time price card at the top of the page for specific billing.

FAQ

How much difference is there between Terra and Sol? There is a 2.6-point gap on the Coding Agent Index (77.4 vs 80). For most production tasks, this gap is not enough to offset the cost difference, but Sol still has a clear advantage on the most complex agent, safety, and science tasks.

How do I choose between Terra and Luna? Choose Terra when you need real reasoning and multi-step planning; choose Luna for high-frequency simple tasks like extraction, classification, and format conversion, where throughput is higher and cost is lower.

Can it be used together with Sol? Yes, and it's recommended. All three tiers share the same interface and API key — you can implement tiered routing by dynamically selecting the model ID based on request complexity.

What inputs are supported? Text and images. Tool calling, streaming output, and reasoning effort control are all available.

What is the output limit? Up to 256K output tokens per request. For long content generation, streaming is recommended.

Is migrating from the previous GPT generation troublesome? No. The interface remains OpenAI-compatible — just change the base URL and model ID, and prompts can generally be reused as-is with minor tuning.

Why Use GPT-5.6 Terra API on SeaWhale AI

Free switching across three tiers — One key covers Sol / Terra / Luna, with tiered routing based on task value
OpenAI-compatible — Existing SDK code can be integrated with just two changed lines
Centralized cost management — Usage, billing, and budgets viewed on a single platform
Multi-model tech stack — Shares the same infrastructure as Claude, Gemini, Qwen, and others

API

API integration

Model IDUse this value as the model in inference requests

gpt-5.6-terra

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-terra 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-terra",
    "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-terra",
    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-terra',
  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 ?? '')
}