API429 / gpt-5.6-luna

GPT-5.6 Luna API: data extraction, pricing and integration

OpenAI describes GPT-5.6 Luna for cost-sensitive high-volume tasks. For an existing integration, test simple field extraction and compare with GPT-6 Luna. The exact model name, technical contract and current customer rate must be checked independently.

Read in Russian

Published: · Updated:

Exact ID: gpt-5.6-luna. Check access for your key using GET /v1/models; a published model does not guarantee access for every account.

Prices and billing units

API429: published ratesManufacturer: base Standard
$0.375000000000 / 1,000,000 cache-write input tokens · Context up to 272,000 tokens inclusive
$0.750000000000 / 1,000,000 cache-write input tokens · Context over 272,000 tokens
$0.030000000000 / 1,000,000 cached input tokens · Context up to 272,000 tokens inclusive
$0.060000000000 / 1,000,000 cached input tokens · Context over 272,000 tokens
$0.300000000000 / 1,000,000 input tokens · Context up to 272,000 tokens inclusive
$0.600000000000 / 1,000,000 input tokens · Context over 272,000 tokens
$1.800000000000 / 1,000,000 output tokens · Context up to 272,000 tokens inclusive
$2.700000000000 / 1,000,000 output tokens · Context over 272,000 tokens
$3.000000000000 / 1,000 web-search calls
$0.2 / $1.2 per 1M ordinary input / output tokens

Standard; input ≤272,000 tokens

Manufacturer sourceChecked: Oct 24, 2026. Cache, tools and special modes are excluded from this rate pair.

API429 catalog generated . This dates the catalog data, not the model’s addition.

Workload budget: input and output

API429$1.5
Manufacturer$1
Difference from manufacturer price-50%API429 costs more for this workload

Ordinary input and output are counted, excluding cache, tools, fees and repeated calls. This estimates spending; it does not validate whether a request is accepted. RUB results use only your entered rate; they are neither a bank quote nor a top-up amount.

Specifications and compatibility boundaries

The manufacturer specifies a context window of 1,050,000 and a maximum output of 128,000 tokens for its own API (specification: OpenAI, checked Oct 24, 2026). These are not verified effective API429 limits: the current public catalog does not publish them. Confirm the required volume and mode before migrating your workload.

API429 capabilities published for this exact ID: chat . A missing property does not mean a prohibition, but it does not establish support. Check input format, tools, JSON/schema, reasoning and streaming separately for the selected method.

Extracting one field: define a missing value

A simple control scenario for GPT-5.6 Luna is extracting a programming language from a short support request. Add texts with no language, two languages and a name resembling an ordinary word for a useful evaluation. Decide in advance whether the answer should contain one value, a list or a missing-information marker. This page’s example is synthetic and checks only a small text call. For a working sample, compare the extracted field against a reference and count invented values separately. The manufacturer positions Luna for cost-sensitive high-volume tasks, but that does not establish extraction accuracy in your domain. If data will feed search or reporting, validate allowed values and provide a correction path without reprocessing the entire source queue.

The Luna name is not an alias for an earlier nano

The official page says GPT-5.6 Luna roughly corresponds to the nano tier of earlier families. That describes a task class rather than the same model or one exact predecessor. Do not replace an old ID automatically or transfer limits based on similar names. The native OpenAI GPT-5.6 family has reasoning effort modes from none to max; the guide also describes changes in caching and reasoning retention. These details concern the direct manufacturer API. The basic API429 example uses only model, messages, max_tokens and stream. Additional modes need separate checks against client documentation and the specific request. Compare with GPT-6 Luna as two exact IDs too, preserving source material and evaluation rules.

Extraction estimates: include retries and long documents

The cost of one successfully extracted field depends on more than its base rate. Include resent instructions, incorrectly formatted responses and extra review of disputed cases. By default the calculator estimates ordinary input and output tokens for independent requests, excluding cache and tools. Do not use the historical launch price in place of the current one: the official changelog records a GPT-5.6 Luna price reduction on July 30, 2026. For API429, use its own fresh published rate. At OpenAI, input above 272,000 tokens moves the entire request to higher input and output rates, rather than only the excess. A large document and many short records can therefore need different estimates even with the same total text volume.

Migrating an existing workflow requires history checks

When migrating from an earlier family, check more than the first answer. Prepare a two-step scenario: extract a field, then clarify it with new information. The native GPT-5.6 guide changes reasoning retention behavior and describes new caching rules. Your application must check which messages and results it passes between requests; do not assume an SDK or gateway transfers everything automatically. These manufacturer parameters are not included in the page’s simple example. Begin with gpt-5.6-luna access under your key, an ordinary response and a small max_tokens. Then test stream parsing, truncated results and retries after timeouts. OpenAI’s maximum context does not establish an effective API429 limit. Check the required history volume and data format in your specific integration.

Public model observations

There are no fresh observations with confirmed traffic for this model. This does not mean zero latency or prove an absence of errors.

Source: public 24-hour statistics. The mean is neither a median nor a response time guarantee; the error rate and observation window refer to the API429 service. Model quality is not measured here.

First request: curl, Python, JavaScript

Create a key, check your balance and set API429_API_KEY on the server. The generation example incurs a charge. It does not retry automatically; a timeout does not prove the operation was not charged. Inspect the content and actual usage after receiving a response. Python and JavaScript first check the available model list.

curl

Before generation, check the exact ID in the response from GET https://gateway.api429.com/v1/models using the same Bearer key.

curl --fail-with-body https://gateway.api429.com/v1/chat/completions \
  -H "Authorization: Bearer $API429_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.6-luna","messages":[{"role":"user","content":"Extract the programming language from “I need a Python example for chat”. Reply with one word."}],"max_tokens":512,"stream":false}'

Python 3

import json
import os
import urllib.request

key = os.environ["API429_API_KEY"]
base = "https://gateway.api429.com/v1"
headers = {"Authorization": "Bearer " + key, "Content-Type": "application/json"}
models_request = urllib.request.Request(base + "/models", headers=headers)
with urllib.request.urlopen(models_request, timeout=30) as response:
    available = {item["id"] for item in json.load(response)["data"]}
model = "gpt-5.6-luna"
if model not in available:
    raise ValueError("Model is unavailable to this key")
payload = json.loads("{\"model\":\"gpt-5.6-luna\",\"messages\":[{\"role\":\"user\",\"content\":\"Extract the programming language from “I need a Python example for chat”. Reply with one word.\"}],\"max_tokens\":512,\"stream\":false}")
request = urllib.request.Request(base + "/chat/completions",
    data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=60) as response:
    result = json.load(response)
choice = result["choices"][0]
if choice.get("finish_reason") != "stop" or not choice.get("message", {}).get("content"):
    raise ValueError("Incomplete or empty response")
print(choice["message"]["content"])
print(result.get("usage"))

JavaScript: Node.js 18+

const key = process.env.API429_API_KEY;
if (!key) throw new Error("Set API429_API_KEY");
const base = "https://gateway.api429.com/v1";
const headers = { Authorization: "Bearer " + key, "Content-Type": "application/json" };
const model = "gpt-5.6-luna";
const available = await fetch(base + "/models", { headers, signal: AbortSignal.timeout(30000) });
if (!available.ok) throw new Error("Models HTTP " + available.status);
if (!(await available.json()).data.some(item => item.id === model)) throw new Error("Model unavailable to this key");
const response = await fetch(base + "/chat/completions", {
  method: "POST", headers, signal: AbortSignal.timeout(60000),
  body: JSON.stringify({"model":"gpt-5.6-luna","messages":[{"role":"user","content":"Extract the programming language from “I need a Python example for chat”. Reply with one word."}],"max_tokens":512,"stream":false})
});
if (!response.ok) throw new Error("Generation HTTP " + response.status);
const result = await response.json();
const choice = result.choices?.[0];
if (choice?.finish_reason !== "stop" || !choice?.message?.content) throw new Error("Incomplete or empty response");
console.log(choice.message.content);
console.log(result.usage);

The examples use basic fields from the published API contract. They are checked offline; no successful paid execution or output accuracy is claimed.

n8n: minimal HTTP Request

  1. Create an HTTP Request with method POST and URL https://gateway.api429.com/v1/chat/completions.
  2. Store the Bearer key in credentials; add Content-Type: application/json. Do not put the key in an exported workflow example.
  3. Send the JSON from curl: the exact model gpt-5.6-luna, messages, max_tokens and stream=false.
  4. After the HTTP node, check choices, finish_reason and the response content before writing the result to your production system.

HTTP Request documentation. This recipe describes HTTP Request. Compatibility with specific Agent nodes, SDKs and other API methods needs separate verification.

Three models for your own comparison

These are options for a controlled comparison on the same task, rather than a quality ranking. Base rates apply to a short text request; see the catalog for full pricing.

ModelAPI429: input / output per 1M tokens
GPT 6.1 Solgpt-6.1-sol$0.6 / $3
GPT 6 Astragpt-6-astra$3 / $15
GPT 6 Solgpt-6-sol$0.6 / $3

Version and release date

Manufacturer API release date, OpenAI: . The exact predecessor has not been established in the reviewed sources. The date of addition to API429 is unknown. Current availability is determined by the catalog and key permissions, rather than the manufacturer’s historical release date.

Frequently asked questions

Is GPT-5.6 Luna the former nano model?

OpenAI describes an approximate correspondence to the nano tier in earlier families. This does not prove identity, an alias or one predecessor. Use the exact gpt-5.6-luna from your key’s model list and evaluate results separately.

Can I use the price from a launch announcement?

Current budgets require a current rate: OpenAI announced a Luna price reduction on July 30, 2026. Check API429 customer pricing in its fresh catalog rather than deriving it from historical prices or another model.

What should I check when replacing it with GPT-6 Luna?

Compare extraction of missing and ambiguous values, response format and retries. Then check conversation history and required request parameters. A newer name and different rate do not prove automatic compatibility with your workflow.

Will a long context let me process a document in one request?

A manufacturer specification does not promise your API429 key’s effective limit. Beyond size, evaluate extraction completeness, output limits and the 272K pricing boundary. Test a small document and increase input gradually, retaining usage and missed-field records.

Sources and review

Editorial review: . Pricing and general calculator · Getting started · Compare the family: OpenAI

Telegram