To choose a Large Language Model, this article compares Qwen4-Max and GPT-6 Luna on their shared leaderboard metrics, long-context pricing, and input modalities, turning composite scores into acceptance criteria and cost judgments for specific tasks.
Here’s the conclusion first, then the conditions. If the task requires video input, the two model cards mean you can only consider Qwen4-Max for now; GPT-6 Luna doesn’t make the candidate list. If it’s a text-only or text-plus-image task, and per-call cost and call volume are hard constraints, GPT-6 Luna’s list price is much lower, so it’s worth treating as the default tier. For high-complexity work such as multi-step automation, Qwen4-Max clearly leads on some Artificial Analysis subscores, making it a candidate for a high-complexity routing tier. Which tier you ultimately use depends on the acceptance pass rate on your own task set and the cost per accepted task.
Three conditions can change this conclusion. First, depending on which reasoning tier Luna uses, the spread in index score and cost per task can go from roughly 22x to roughly 77x. Second, once the input passes 272,000 tokens, Luna bumps the entire request to a higher tier under OpenAI list pricing. Third, the subscore gap on a specific task can be very small—for example, on FrontierCode-AA 2.0 the two are only 1.3 percentage points apart.

Large Language Model Selection Comparison at a Glance: Qwen4-Max vs GPT-6 Luna
The table below lists only the dimensions that actually affect selection. Scores come from Artificial Analysis’s Intelligence Index v5.0.1, and prices come from vendors’ public list prices or the APIYI catalog. All of it is public information as of this article’s verification date, 2026-11-20 — not our paid hands-on testing.
| Comparison dimension | Qwen4-Max | GPT-6 Luna | What the difference means |
|---|---|---|---|
| Input modality (vendor model card) | Text, image, video | Text, image | Video tasks rule out Luna immediately |
| Output modality | Text | Text | Neither generates images or speech |
| Intelligence Index v5.0.1 | 43 points | Medium tier 18 points; Max tier 28 points | Different tiers, different gaps |
| Index task cost | $3.27 | Medium tier $0.0422; Max tier $0.15 | Only applies to that index workload |
| Vendor list price (per million tokens, short context) | Alibaba Cloud Singapore: input $1.50, output $4.50 | OpenAI standard: input $0.10, output $0.50 | Input roughly 15 to 1, output 9 to 1 |
| Long-input pricing | Third-party sources say a flat rate across the full window | Requests over 272,000 tokens bump the whole request up a tier | Long-document scenarios need separate calculation |
| APIYI catalog endpoints | chat, responses, messages | Chat Completions, Responses | Protocol choice affects migration cost |
| Available platforms | APIYI apiyi.com, Alibaba Cloud Model Studio, and others | APIYI apiyi.com, OpenAI official, and others | A single key makes back-and-forth comparison easy |
The main text follows the dependency order of selection. Section 1 first confirms whether you can integrate at all, because if modality or endpoint requirements aren’t met, the scores and prices that follow don’t mean anything. Section 2 compares performance under the same benchmark. Section 3 breaks down vendor price, catalog price, and actual account payment at the same usage volume. Section 4 turns the earlier judgments into steps you can re-test on your own business. If you only care about cost, feel free to jump straight to Section 3 — but I’d suggest glancing at the elimination criteria in Section 1 first.
Terms to Know Before Selecting a Large Language Model (To Know)
| Term | Meaning in this article |
|---|---|
| Intelligence Index | Artificial Analysis’s aggregated score of performance across multiple tasks under a specified version; this article uses v5.0.1 |
| Index task cost | The estimated consumption for completing one task in that benchmark; the reasoning tier and input/output volume both change the result |
| Reasoning tier | Controls the thinking intensity the model invests — for example, Luna’s Medium and Max. It must be stated whenever you compare |
| Input modality | The type of content the model accepts, such as text, image, or video |
| Context tiered pricing | Billing at a different rate once input exceeds a threshold; you need to confirm whether only the excess portion or the whole request is charged |
| Cache read | A billing line item for reusing existing input; should be counted according to the price list and actual hit records |
| First visible answer token latency | The time from sending a request to the first usable answer segment appearing. For reasoning models, distinguish this from the “first event” |
| P50 / P95 | The median and 95th percentile of the latency distribution, reflecting typical values and slow requests respectively |
| Qualified task cost | Spreading the cost of failures, review, and rework across every actually qualified result |
1. Step One in Large Language Model Selection: Rule Out Unsuitable Combinations Based on Task Constraints
The most cost-saving move in model selection is elimination first. No matter how high a model’s score is, if it can’t accept your input types or call protocol, you have to let it go; conversely, if a cheap model fails on hard constraints, there’s no point calculating costs later.
1.1 Use Model Cards to Distinguish Input Modalities
The model card for Alibaba Cloud Model Studio lists Qwen4-Max as accepting text, image, and video input, and outputting text. OpenAI’s model card lists GPT-6 Luna as accepting text and image input, and outputting text; OrcaRouter’s write-up also notes that Luna doesn’t support image generation, speech generation, transcription, or translation. This is the hardest difference between the two, and it means video-type tasks have only one candidate: Qwen4-Max.
One thing to keep in mind: a vendor’s model card describes the model’s own capabilities. Whether video parameters can actually be passed through depends on the specific integrator and endpoint, so you need to verify that separately. For example, Together AI’s model page explicitly lists text and image input, but I couldn’t find any documentation for video on that same route — so all you can say is “Together explicitly lists text and image,” not that it supports video.
1.2 Verify IDs, Groups, and Endpoints Against the APIYI Catalog
APIYI announced the launch of qwen4-max on 2026-11-17, and the public model registry generated on 2026-11-20 lists its endpoints as chat, responses, and messages, with the groups ClaudeCode, CodexResponses, default, and svip. gpt-6-luna appears in the price table with Default and SVIP groups and Chat Completions and Responses entries. The earlier blog claim that “Qwen4-Max isn’t available yet” should be superseded by the latest announcement and registry.
The catalog only proves that the platform supports the model and endpoints. The group your account belongs to and the permissions on your token affect whether you can actually call it. My suggestion: after creating a token in the APIYI apiyi.com console, first send one minimal request to confirm that the exact model ID and endpoint work, then move on to comparing quality.
1.3 The Non-Negotiable Constraints for Each of the Three Scenarios
| Scenario | Non-negotiable constraint | Elimination result | Next focus |
|---|---|---|---|
| Text record organization (meeting minutes, ticket archiving) | Stable output format, low per-call cost, high call volume | Both make the cut | Compare format pass rate and unit cost |
| Video understanding (screen-recording QA, video summarization) | Must accept video input | Eliminate GPT-6 Luna based on the model card | Check whether endpoints and tokens support video parameters |
| Complex workflows (multi-step automation, cross-system operations) | High multi-step execution success rate, failure is expensive | Both make the cut | Prioritize acceptance pass rate over unit price |
Text record organization is a classic cost-sensitive scenario. The task itself isn’t hard; what matters is the average cost per result when you’re making calls at scale. Video understanding is a capability gate — if the modality doesn’t match, there’s nothing to compare. And failures in complex workflows usually mean manual rework, so a cheap model that fails a few extra times may end up costing more in practice. I’ll run the numbers in Sections 3 and 4.
2. Step Two of Large Language Model Selection: Compare Returns on the Same Benchmark
After you’ve narrowed the field, look at performance. Here we only use data from the same comparison page published by Artificial Analysis, because different leaderboards use different task sets and scoring methods, so mixing them into one ranking doesn’t make sense.
2.1 Read the composite score and task cost together with the tier
| Configuration | Intelligence Index v5.0.1 | Index task cost | Cost multiple relative to Qwen4-Max |
|---|---|---|---|
| Qwen4 Max | 43 | $3.27 | 1 |
| GPT-6 Luna (Medium, default tier) | 18 | $0.0422 | about 1/77 |
| GPT-6 Luna (Max tier) | 28 | $0.15 | about 1/22 |
The often-cited “about 22x” comes from $3.27 ÷ $0.15 and compares Qwen4 Max with Luna’s Max tier. Here the score gap is 15 points. If you compare against Luna’s default Medium tier, the cost multiple is about 77x and the score gap is 25 points. So just saying “22x more expensive” isn’t the whole story—you also need to specify the tier and the workload.
Another detail is data completeness. OrcaRouter points out that the leaderboard published only one score for Qwen4-Max, with no tier-level data; Luna, by contrast, discloses a complete tier ladder. When forecasting costs, a complete ladder lets you see the inflection point for whether the score still improves as you move up tiers. That kind of information is sometimes more useful than a single higher score.

2.2 Sub-score gaps vary by task
The overall index can’t predict the return on a specific task. On AutomationBench-AA, Qwen4 Max scores 72.6% and Luna Max scores 53.2%, a gap of about 19 percentage points; on FrontierCode-AA 2.0, they score 26.5% and 25.2%, respectively, a gap of just 1.3 percentage points.
Looking back at the scenarios from Section 1, complex workflows are closer to multi-step automation tasks like AutomationBench, so Qwen4-Max’s lead may translate into less rework. If your tasks are closer to something like FrontierCode, the gap between the two is very small while the unit price gap is still large, so Luna’s price-performance ratio is more compelling. This is only a directional judgment; you’ll still need to verify it on your own task set.
3. Step Three in LLM Selection: Price the Vendor Rate, Catalog Rate, and Account Fees Separately
Cost is the thing people most easily lump together. This section splits it into three layers: the vendor’s public list price, the APIYI catalog price, and what your account actually pays after top-up bonuses. They belong to different layers and can’t stand in for each other.
3.1 Vendor Pricing Example for the Same Long-Input Request
Say a single request has 400,000 input tokens and 8,000 billed output tokens, with no cache hits and no extra tool fees.
| Item | Qwen4-Max (Alibaba Cloud International, Singapore standard pricing) | GPT-6 Luna (OpenAI standard pricing, long input) |
|---|---|---|
| Input rate | $1.50 / million | $0.20 / million (whole request steps up once it exceeds 272,000) |
| Output rate | $4.50 / million | $0.75 / million |
| Formula | 0.4 × 1.50 + 0.008 × 4.50 | 0.4 × 0.20 + 0.008 × 0.75 |
| Cost per request | $0.636 | $0.086 |
That’s roughly 7.40x — about half the 15-to-1 input rate gap you see under short context. The reason is Luna’s tier step-up rule. Under OpenAI’s list pricing, the long-input step-up applies to the entire request rather than only the portion above the threshold: for a 300,000-token prompt, all 300,000 tokens are billed at the higher rate, not just the last 28,000. OrcaRouter’s write-up says Qwen4-Max bills at a single rate across the whole million-token window, with no 32K or 128K tiers.
Vendor prices also shift by region and channel. OrcaRouter lists Qwen4-Max in the Global region at $1.413 input and $4.24 output, different from Singapore. Together AI’s official Pricing page marks Qwen4 Max as a promotion with a limited-time price of $1.05 input, $3.15 output, and $0.0525 cache read — exactly 70% of the Singapore price. The page says it’s valid through 2026-11-23 but doesn’t specify a time zone; meanwhile its model detail page shows a different set: $1.43, $4.28, $0.0713. When you cite prices like these, spell out the source page and the date — actual billing is based on your account’s usage.
3.2 APIYI Catalog Prices Calculated from Catalog Rates and Usage Logs
In the APIYI catalog, qwen4-max is $1.50 per million input Tokens, $4.50 for output, and $0.075 for cache reads; gpt-6-luna is $0.10 for short-context input, $0.50 for output, and $0.01 for cache reads, with the price table noting that input rises to $0.20 once input exceeds 272,000 Tokens.
Applying the same request from 3.1, qwen4-max comes out to the same $0.636 at catalog price. For gpt-6-luna, the input portion is 0.4 × 0.20 = $0.08; the price table checked in this round only specifies the input tier upgrade, so which rate applies to the output portion under long context should be confirmed against the current price table and usage logs. The real cost number should come from the usage logs in your account, not from the formulas above.
💰 Cost accounting tip: Call both models under the same APIYI account at apiyi.com — the usage logs record the input, output, and cached Tokens for each request, which gets you closer to your actual bill than estimates based on public list prices.
3.3 Top-Up Bonuses Affect the Principal Conversion, Not the Per-Model Unit Price
APIYI’s current FAQ lists per-transaction top-up tiers: $100 to under $500 gets a 10% bonus, $500 to under $1,000 gets 12%, $1,000 to under $3,000 gets 15%, and $3,000 and up gets 20%. Both online and corporate-account top-ups qualify, and the bonus is issued automatically; whether separately negotiated business pricing can stack on top needs to be confirmed case by case. Regular users get an extra $1 on their first top-up, and education users verified with a school email get $2 — contact support to have it issued. The topped-up balance follows the 365-day rule described in the documentation.
| Top-up tier | Balance credited | Log $1 equivalent to top-up principal | Principal cost reduction |
|---|---|---|---|
| Single $100 | $110 | about $0.909 | about 9.09% |
| Single $3,000 and up | top-up amount × 1.2 | about $0.833 | about 16.67% |
The premise here is that the entire bonus balance gets used. At the 10% tier, the $0.636 single-request log cost from 3.1 corresponds to roughly $0.578 of top-up principal. Keep in mind that the bonus applies uniformly to your whole-site balance — what it lowers is the principal behind every $1 of log credit, and it shouldn’t be read as an extra discount on any particular model. When comparing options, use the same conversion factor on both sides, otherwise the comparison will be skewed.
4. Step 4 of Large Language Model Selection: Turn Conditions into Testable, Comparable Steps
The previous three sections rely on public information. What really decides which model you pick is your own task’s pass rate, latency, and cost under the same conditions. Right now we don’t have success rate, latency, or billing data from the APIYI platform for the two models on the same task in the same group, so below is a comparison test protocol you can run yourself.
4.1 Control variables and record fields
In a comparison test, try to change only one variable: the model. Specifically, use the same mainland node and carrier, the same APIYI group and protocol, the same input set and output cap, and send requests to the two models alternately at the same concurrency. That avoids the time-of-day bias that comes from finishing one model before running the other.
| Record field | Purpose |
|---|---|
| Whether it passes acceptance | Calculate pass rate and cost per qualified task |
| HTTP status, request ID | Troubleshoot failures and reconcile with usage logs |
| Latency to first visible answer token | Measure interactive experience; for reasoning models, record this separately from the first event |
| Total duration | Measure batch throughput |
| Cold/hot connection, cache hit | Explain fluctuations in latency and cost |
| Input and output token counts | Verify actual billable usage |
It’s best to record DNS, TCP, and TLS timing separately. When reporting, clearly state the sample size, pass rate, P50, and P95. For public comparisons, you can refer to the definitions of success rate, first-token latency, and throughput in the China Academy of Information and Communications Technology (CAICT) report.

4.2 The Minimal Script for Alternating Comparison Testing
The script below alternates calls between two models through the OpenAI-compatible interface, using streaming output to measure the first visible answer token and the total elapsed time. You’ll need to swap in an acceptance function that fits your own task. If you need to set a reasoning tier, check the APIYI docs for the exact parameter name before adding it, and make a note of it in your records.
import time, statistics, openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # APIYI unified endpoint, both models share one key
)
MODELS = ["qwen4-max", "gpt-6-luna"]
TASKS = ["把下面的会议记录整理成 JSON:...", "..."] # replace with your own task set
def passed(task, answer):
return answer.strip().startswith("{") # replace with your real acceptance rule
records = {m: [] for m in MODELS}
for task in TASKS:
for model in MODELS: # alternate requests to reduce time-window bias
start, first = time.perf_counter(), None
text = ""
stream = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": task}],
max_tokens=2000, # both models use the same output cap
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
if first is None:
first = time.perf_counter() - start # first visible answer token
text += chunk.choices[0].delta.content
total = time.perf_counter() - start
records[model].append({"ok": passed(task, text), "ttft": first, "total": total})
for m, rs in records.items():
ttfts = sorted(r["ttft"] for r in rs if r["ttft"] is not None)
n = len(rs)
print(m, "样本", n, "通过率", sum(r["ok"] for r in rs) / n,
"首字P50", statistics.median(ttfts) if ttfts else None,
"首字P95", ttfts[int(0.95 * (len(ttfts) - 1))] if ttfts else None)
For token usage and cost, it’s best to pull the totals straight from the platform’s usage logs, aggregated by request ID, and then plug them into the formula below.
4.3 Cost per Qualified Task and Tiered Routing
Cost per qualified task = total invocation cost (including failures and retries) + manual review and rework cost, divided by the number of tasks that ultimately pass acceptance. If a lower-priced model has a low pass rate, the denominator shrinks and the numerator grows, so its cost per qualified task can end up higher than that of a more expensive model. Conversely, if the two pass rates are close, the price difference will show up almost unchanged in the final result.
Based on this, you can route requests by task complexity in tiers: ordinary tasks go to gpt-6-luna by default, while highly complex tasks or video tasks go to qwen4-max. Before enabling a route, first check whether its acceptance pass rate on the relevant task set meets the bar, then look at the cost per qualified task. Since both models sit behind the same OpenAI-compatible API at APIYI apiyi.com, switching routes only requires changing the model field.
🎯 Benchmarking tip: New users can first use the sign-up trial credit listed on the APIYI apiyi.com Quick Start page to get their script running, then top up based on the size of their task set for a formal benchmark comparison.
4.4 Endpoint Probe Data Only Shows Measurement Boundaries
Lingjian AI’s public monitoring table sampled the APIYI domain from mainland China nodes. Three HTTP 200 records from 2026-11-05 to 11-06 had latencies of 429, 569, and 565 ms, respectively. These probes only reflect endpoint connectivity. The page even counts some HTTP 404s as normal, and it doesn’t specify the request payload or authentication method, so they can’t be used to infer model generation latency or success rate. Artificial Analysis’s time to first token only represents its own evaluation environment; results under your network and concurrency conditions need to be measured separately using the method in 4.1.
Back to the question in the title: video input is a hard requirement, and only Qwen4-Max meets it. In text-only and image-text tasks, GPT-6 Luna’s list-price advantage is greatest at short context and narrows once input exceeds 272,000 tokens. On highly complex multi-step tasks, Qwen4-Max’s category-level lead may offset the unit-price gap. All three conclusions depend on tier, input length, and task type; ultimately, the cost per qualified task on your own task set is what counts. When you need a single entry point for alternating benchmark comparisons, you can call both models through APIYI apiyi.com with one API key.
References
- Artificial Analysis – Qwen4 Max vs. GPT-6 Luna release comparison: Intelligence Index v5.0.1 scores and sub-scores
- Link:
artificialanalysis.ai/zh/models/comparisons/qwen4-max-vs-gpt-6-luna
- Link:
- Alibaba Cloud Model Studio – Qwen4-Max model card and price list: input modalities and Singapore standard pricing
- Link:
alibabacloud.com/help/en/model-studio/model-pricing
- Link:
- OpenAI – GPT-6 Luna Model: input modalities and long-context pricing
- Link:
developers.openai.com/api/docs/models/gpt-6-luna
- Link:
- OrcaRouter – Qwen4-Max vs GPT-6 Luna: unit price ratios, notes on the 272,000-token tier
- Link:
orcarouter.ai/blog/qwen-4-max-vs-gpt-6-luna
- Link:
- Together AI – Pricing: limited-time promotional pricing for Qwen4 Max
- Link:
together.ai/pricing
- Link:
- APIYI – Full model pricing table, model registry, and top-up campaign FAQ: list prices, endpoint groups, and bonus tiers
- Link:
docs.apiyi.com/models
- Link:
- CAICT et al. – Large Language Model token service performance monitoring report (2026): definitions of success rate, first-token latency, and throughput
- Link:
caict.ac.cn
- Link:
Author: APIYI Technical Team
Technical discussion: Feel free to reach out to us through the homepage of the APIYI apiyi.com website. For more integration materials, visit the docs.apiyi.com documentation center.