gpt-6-luna ★

Name: gpt-6-luna
Brand: OpenAI

OpenAIChatReasoningVision

Get your API key

gpt-6-luna

An efficient multimodal reasoning model for everyday batch tasks

GPT-6 Luna is a multimodal reasoning model in the OpenAI GPT-6 family that emphasizes efficiency and cost of use, suitable for breaking down daily business operations into tasks with clear boundaries and repeatable acceptance criteria. It continues the same-generation improvements in factuality, programming, and collaborative communication, and can be used for text classification, data extraction, screenshot analysis, and localized code assistance; compared with Sol and Astra, it is better suited as a go-to choice for high-frequency tasks.

Try this model View pricing

OpenAIModel brand

ChatModel type

Reasoning, visual understandingTask capabilities

STANDARD APIs · QUICK SETUP

Keep your SDK. Connect in minutes.

Point the Base URL to api.acedata.cloud, configure your platform API key and the model ID below, and use your compatible SDK or client.

API host: api.acedata.cloud
model: gpt-6-luna

Get your API key

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ACEDATACLOUD_API_KEY"],
    base_url="https://api.acedata.cloud/v1",
)
response = client.responses.create(
    model="gpt-6-luna",
    input="Hello!",
)
print(response.output_text)

Choose an available protocol for this model. OpenAI SDK uses a Base URL ending in /v1; Anthropic SDK uses the root URL. See each guide for protocol-specific parameters, tools and response formats.

Specifications and interface features

Clarify capacity, input and output, and calling methods before selecting a model.

Input methods: Text, images; Chat Completions can combine text and image_url content blocks
Primary output: Text responses; Chat Completions provides JSON format settings
Reasoning control: Native none, low, medium, high, xhigh, max; field and tool limitations vary by protocol
Response method: Chat Completions and Responses provide stream control
Output budget: Responses can set max_output_tokens; Chat Completions provides response length control
Native context window: 1,050,000 tokens
Native maximum input: 922,000 tokens; must be planned together with output
Native maximum output: 128,000 tokens

GPT-6 Luna's multimodal reasoning positioning and interface operations are described separately; format, tools, and output budget are configured according to the selected endpoint.

Core Capabilities

Learn what gpt-6-luna can bring to your work.

Turn repetitive business work into clear tasks

Luna is well suited to work with focused goals and fixed delivery formats, such as labeling ticket intents, extracting order fields from emails, and generating short summaries according to rules. Providing label definitions, missing-value rules, and examples together is easier to validate than simply asking it to “analyze content,” and it is also suitable for handling independent subtasks within larger workflows.

Balance factual judgment with clear communication

Compared with GPT-5.6 Luna, improvements in the same generation include factuality and collaborative communication. It is better suited to organizing provided materials into clear conclusions, evidence, and items to confirm, reducing irrelevant terminology and lengthy explanations. For questions that require judgment rather than mechanical extraction, task evaluation can be combined with reasoning controls, without requiring every response to be maximally elaborate.

Connect image and text analysis with coding assistance

The model has vision and reasoning capabilities, enabling it to structure responses around screenshots, charts, and written descriptions, and to assist with code explanations, error analysis, and localized changes. Official software engineering evaluations show that it can handle relatively complex programming tasks; in actual use, you should still provide relevant code, error information, and acceptance criteria to keep the scope of changes under control.

Use Cases

Start with specific tasks to find where the model can be effective.

Customer support ticket classification and field extraction

Provide the ticket body, business label descriptions, and target fields, and have Luna return the category, order number, issue summary, and missing information. Keep the rationale separate from the field results to facilitate manual spot checks; when machine-readable output is needed, configure JSON output and have the application check required fields, enum values, and formats before proceeding to subsequent business workflows.

Assisted interpretation of screenshots and charts

Submit product screenshots or chart links together with specific questions, such as comparing interface states, summarizing trends in a chart, or describing visible information on an error page. Deliverables can include an observation checklist, a summary of differences, and suggestions for further investigation. Tasks should focus on content visible in the image, avoiding asking the model to guess obscured text or background information that was not provided.

Localized code review and test drafts

Provide function code, exception logs, and expected behavior, and have Luna explain possible causes, propose limited-scope changes, and generate test case drafts. For recurring code explanations or localized checks, a standardized prompt template can be used. The final deliverable should include the rationale for changes and verification steps; test execution and merge decisions should still be completed by the development environment and team.

How to Choose This Model

Choose based on task complexity, input materials, and expected results.

How to Choose Between Luna, Sol, and Astra

For clearly bounded classification, extraction, summarization, and local code tasks, prioritize Luna; when tasks involve cross-module changes, long-process planning, or complex tool collaboration, consider GPT-6 Sol. If the project values the highest quality and in-depth judgment rather than efficiency trade-offs, GPT-6 Astra is the more demanding option in the same generation. Assign tasks based on actual acceptance results rather than treating models in the same series as fully equivalent.

What to Look for When Upgrading from GPT-5.6 Luna

GPT-6 Luna continues Luna's efficiency-focused positioning while improving factuality, programming, and collaboration performance. When migrating, replay existing tickets, extraction samples, and code tasks, and compare field accuracy, omissions, and rework. GPT-6.1 Sol is another model, not Luna's new name; do not replace all tasks merely because of a version update. Choose based on business complexity and delivery quality.

Start with a Specific Task

Based on the characteristics of gpt-6-luna, first validate small tasks whose results can be checked.

Bulk Ticket Classification and Summarization

You can ask directly: Process tickets according to these classification rules, and output the category, urgency, original-text evidence, and a one-sentence summary. If information is insufficient, return pending review; do not fabricate user background.

Prepare Input That Supports Judgment

Use real tickets and boundary samples; separately check classification accuracy, missing values, and whether the results are easy for programs to read.

Then Integrate It into Your Workflow

Use the full model ID gpt-6-luna, first confirm the public request format and available parameters on the API page, then connect your application. Preserve result parsing, exception handling, and related evidence, and evaluate whether it is suitable for ongoing use with the same set of real samples.

Usage boundaries

Before formal use, understand the output quality and capability scope.

Improved factuality does not mean answers are necessarily correct. Official factuality evaluations use specific conversations that readily induce errors and cannot directly estimate everyday business accuracy. When handling amounts, dates, contract terms, or critical business conclusions, require supporting evidence and perform rule-based validation or human review for important fields.
Software engineering and computer-use capabilities do not mean that a single request will automatically run tests, modify a repository, or click on a desktop. Code responses should be treated as verifiable suggestions; tool execution requires the appropriate environment, tool definitions, and permissions, and actions involving writes or releases should retain clear approval boundaries.
Image understanding is primarily for analysis and should not be used as a drawing or speech feature. Blurry screenshots, tiny text, and charts lacking context may affect judgment; prioritize submitting clear relevant areas and provide supplementary text explanations. Long materials should also retain the content needed for the task to avoid irrelevant information overwhelming key evidence.
The latest official model documentation states: Responses can be used for function tool workflows; function calling in Chat Completions supports only configurations where reasoning_effort is none. Applications must verify the current platform documentation and model settings, and must not by default continue using tool loops in Chat Completions requests with reasoning enabled.

Frequently Asked Questions

Answers to common questions about using gpt-6-luna.

Which name should I use to call GPT-6 Luna?

Use gpt-6-luna. It refers to GPT-6 Luna and is not an alias for GPT-6 Sol or GPT-6.1 Sol. Chat Completions submits model and messages, Responses submits model and input, and Messages submits model, messages, and max_tokens; read answers according to their respective response structures.

Can GPT-6 Luna view images and generate images?

Luna can be used for image-and-text understanding, such as analyzing screenshots, describing visible content, or answering questions based on charts. Chat Completions can place text and image_url in the same message. Visual understanding and image generation are different tasks; when you need to generate or edit images, choose a dedicated image model.

How can I make Luna produce results suitable for programs to read?

First specify field names, data types, allowed values, and how to handle missing information, then choose JSON output settings. Keep the structure simple for classification or extraction tasks. Even if returned content can be parsed, continue checking field completeness and business constraints; correct formatting does not mean factual correctness.

When is it worthwhile to increase Luna's reasoning effort?

For extraction tasks with straightforward rules and sufficient information, clear instructions are the priority; when facing multi-condition judgments, conflicting information, or code localization, compare results with different reasoning efforts. Chat Completions uses reasoning_effort, Responses uses the reasoning object, and Messages uses thinking and output_config.effort; use quality and usage from real samples to determine the configuration.

Do I need to save the history myself for Luna's ongoing conversations?

Chat Completions and Messages use messages to organize conversation history; Messages tool calls and results use tool_use and tool_result content blocks; Responses organizes input and related conversation content according to the documentation. Provide the latest materials, revised goals, and key constraints each turn; for longer tasks, retain interim summaries and a final version that can be checked independently.

Use it in your favorite tools

Choose a development approach or application suited to this model and follow its setup guide.

Browse all application guides ↗

Input

$0.02per 1M tokens

Official ~~$0.10~~

Output

$0.1per 1M tokens

Official ~~$0.50~~

−79%vs official

Top-up

You pay$13,584for 142,800 credits · $0.0951 / credits46% OFF

You're billed in credits. Pick a top-up tier to see its per-credit rate — the larger the top-up, the cheaper each credit.