GPT-6 Luna on the Felo API: What $0.10 per Million Tokens Actually Buys

GPT-6 Luna is the fast, cost-efficient tier of the GPT-6 series on the Felo API, at $0.10 per million input tokens. Here is what that buys across classification, extraction, chat, and subagent workloads.

The cheapest tier in the lineup is usually the one doing the most work.

Look at where a mature AI product spends its tokens and you will find a boring answer. Not the demo prompts. Not the reasoning showcases. The classifier that tags every inbound ticket. The extractor that turns every invoice into fields. The router that decides which of those two to call. The subagent that reads a file so the expensive model doesn't have to.

GPT-6 Luna is now on the Felo API, and it is aimed at exactly that layer. It is the fast, cost-efficient tier of the GPT-6 series, priced at $0.10 per million input tokens and $0.50 per million output tokens, with the same 1.05M-token context window as its more expensive siblings.

What Luna is

Model ID	gpt-6-luna
Input	$0.10 per million tokens
Output	$0.50 per million tokens
Context window	1.05M tokens
Max output	128K tokens
Latency	Fast
Protocol	Responses
Capabilities	Reasoning, tool calling, structured output (JSON), streaming, vision
Best for	High-volume chat, classification, fast agent loops, cost-sensitive apps

Two things stand out. First, the price: this is a hundredth of the flagship GPT-6 Astra on both input and output, and a twentieth of GPT-6 Sol. Second, what didn't get cheaper: the context window is identical across the GPT-6 line, and the cheap tier still ships reasoning, tool calling, structured output, streaming, and vision. Nothing structural was removed to hit the price.

The rates in units you can actually use

Felo bills in credits, with a reference value of 1,000 credits = $1. Converted, Luna's rates are:

• 1 million input tokens = $0.10 = 100 credits
• 1 million output tokens = $0.50 = 500 credits

Put differently: a million input tokens costs less than a cup of coffee, and the free daily grant on a Standard account, 200 credits, is worth 2 million Luna input tokens if the model is available on your plan. That is not a demo budget. That is enough to classify a real week of support traffic and see what breaks.

Four high-volume jobs, with the math

These are estimates built from typical token counts, not benchmarks. The point is the order of magnitude, which is what a cost decision actually turns on.

Classification. One million support messages, each about 300 input tokens, each producing a 20-token label. Input: 300M tokens, $30. Output: 20M tokens, $10. Total: $40 to classify a million messages, or about four cents per thousand.

Chat. Fifty thousand conversations, eight turns each, where each turn sends a 1,500-token prompt (system, history, retrieved context) and returns 250 tokens. Input: 600M tokens, $60. Output: 100M tokens, $50. Total: about $110 for 400,000 assistant turns.

Extraction. Two hundred thousand documents at 6,000 input tokens each, producing 400 tokens of structured JSON. Input: 1.2B tokens, $120. Output: 80M tokens, $40. Total: $160 for the batch.

Agent subtasks. A billion tokens of input and 200M of output across a month of subagent calls: $100 plus $100. That is the entire "read these files and report back" layer of an agent stack, priced at $200 a month.

Run any of those numbers against the same workload on a flagship route and the reason this tier exists becomes obvious. The high-volume layer is where a bill is won or lost, and it is usually doing work that a smaller model handles well.

Monthly cost by workload on GPT-6 Luna. Illustrative rates.

The cascade: use Luna first, escalate on doubt

The most useful pattern with a cheap tier is not "replace everything with it". It is a cascade: let Luna handle every request, verify the answers you can verify cheaply, and escalate only the ones that fail.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

async function classify(text) {
  const fast = await client.responses.create({
    model: "gpt-6-luna",
    input: `Classify this message as billing, bug, or feature_request. Reply with the label only.\n\n${text}`,
  });

  const label = fast.output_text.trim();
  if (["billing", "bug", "feature_request"].includes(label)) return label;

  const escalated = await client.responses.create({
    model: "gpt-6-sol",
    input: `Classify carefully, then explain in one line.\n\n${text}`,
  });
  return parseLabel(escalated.output_text);
}

The check in the middle is the whole design. If a validator can tell a good answer from a bad one, the validator is what you spend engineering effort on, and the model tier becomes a cost knob. Schema validation, enum membership, confidence thresholds, an LLM grader that runs on five percent of traffic: any of these turn the cascade into a system where the cheap model does the work and the expensive model catches the exceptions.

For tasks with no cheap validator, structured output is the next best thing. Ask Luna for JSON against a schema and reject anything that does not parse. A reasoning-capable cheap model that fails loudly is worth more than one that fails quietly.

What Luna is not for

Luna is a fast tier, and the fast tier is the wrong tool for a few jobs. Long-horizon planning, where one subtle error somewhere in turn three poisons the remaining thirty turns. High-stakes analysis that a human will act on without review. Architecture decisions across a large codebase.

The pattern to avoid is using Luna at the top of an agent and letting its mistakes propagate downward. Cheap models are cheap because they are less reliable on hard reasoning, not because they are worse at reading and formatting. Put Luna where errors are detectable, and put the reasoning-heavy steps on Sol or Astra where a retry is expensive but a wrong answer is worse.

Luna Pro: same price per token, more thinking

One option worth knowing about: GPT-6 Luna Pro runs the same underlying model with reasoning effort set to pro. It keeps Luna's token pricing and trades latency for accuracy, which makes it a reasonable middle ground for batch analysis or extraction jobs where you want more rigor but still can't justify Sol's rates. It is a different model ID on the same key, so comparing the two on your own data costs a string change.

Get started

GPT-6 Luna is live on the Felo API Platform. The model page has the current rates, the parameter reference, and drop-in code for the Responses protocol:

GPT-6 Luna on the Felo API Platform

If your product has a high-volume layer that is currently running on a premium model out of habit, this is the cheapest experiment in the GPT-6 lineup: move one pipeline over, keep your validator in place, and measure both the bill and the error rate for a week.