Qwen: two model tiers, one endpoint, priced per call over x402

Qwen at qwen.x402.press serves two OpenAI-compatible models to agents over x402, with no API key and no account. qwen3.8-flash costs $0.00875 a call on Base; qwen3.8-max costs 29 times that. For developers deciding when to escalate.

What it is

Qwen is a hosted endpoint at https://qwen.x402.press. It answers POST /v1/chat/completions in the OpenAI request and response shape, so an agent built against an OpenAI client needs its base URL changed and a payment step added.

There is no sign-up, no API key and no monthly bill. A call is paid for with an x402 payment against the HTTP 402 challenge the endpoint returns; the completion comes back on the retried request that carries that payment.

For an operations lead the difference is administrative: no credentials to issue or rotate, and no balance to reconcile. The agent holds a small stablecoin balance on a supported chain and pays from it. Nothing is bundled: no trial credit, no seat, no quota. What it adds is a second model at a very different price, and a routing decision the builder has to make deliberately.

What you get

Two models, one request shape

qwen3.8-flash and qwen3.8-max. Both are selected per call in the model field of the same body, so switching between them is a string assignment, not a second integration. GET /v1/models lists what the endpoint serves and costs nothing; read it at start-up rather than hardcoding model names.

The request

The body is the OpenAI chat completions body. model and messages are the parts you always send. The endpoint forwards temperature, max_tokens, top_p, frequency_penalty, presence_penalty and stop to the model, so sampling and stopping behaviour you have already tuned carries over unchanged.

{
  "model": "qwen3.8-flash",
  "messages": [
    {"role": "system", "content": "Classify each support ticket."},
    {"role": "user", "content": "My invoice shows a charge I do not recognise."}
  ],
  "temperature": 0.2,
  "max_tokens": 200
}

The response comes back in the OpenAI shape, so your existing parsing code will read it — including for qwen3.8-max, which takes the identical body.

The free calls

Three things on this service cost nothing. GET /v1/models lists what the endpoint serves. Recent feedback can be read at /qwen/feedback. Feedback can be submitted against a response_id with a rating from 1 to 5 and an optional comment. None of these is billed.

Feedback is worth wiring when two tiers are in play. It records whether a response was good, keyed to the response rather than the request. That is the record a routing rule needs to audit itself: the price says what a call cost, the rating says whether the escalation was warranted. It is a record of quality, not a support line: no ticket, no reply timescale.

What it costs

Six of the seven supported chains quote two amounts per call, under two schemes. Under exact you pay a fixed prepaid amount; under upto you authorise a metered ceiling and the charge settles on measured input and output tokens. The exact amount does not move with the length of the prompt; the settled amount under upto does, within that ceiling. Avalanche quotes exact only, on both models.

Table 1. qwen3.8-flash: price per POST /v1/chat/completions in US dollars, by settlement chain and payment scheme. Source: live 402 handshake, 30 October 2026, outside peak windows.

The upto amount is the ceiling at max_tokens: 1000; it rises with the output allowance you authorise (see below).

Table 2. qwen3.8-max: the same call on the second model. Same source.

The upto amount is the ceiling at max_tokens: 1000; it rises with the output allowance you authorise (see below).

On Base, qwen3.8-max costs $0.256125 for the call that qwen3.8-flash answers for $0.00875. That is 29.27 times the price. The model named in the request sets the price; the upto ceiling is the one number that moves independently of it, and it follows the max_tokens you authorise.

On Base the exact and upto amounts are identical, on both models: $0.00875 and $0.256125 under either scheme. That parity holds at a 1,000-token ceiling. Measured on Base, the flash ceiling holds at $0.00875 at 1,000 and moves to $0.011021 at 8,000, $0.033581 at 32,000 and $0.126708 with max_tokens unset; on qwen3.8-max it holds at $0.256125 to 8,000, then moves to $0.387504 at 32,000 and $1.576368 unset. Metering is free only at the smallest allowance, and the premium above it is a function of the output you authorise, not of the scheme. The 36% and 96% gaps quoted on DeepSeek’s Base ceiling — flash and pro respectively — are measured at a 1,000-token ceiling too, and widen from there. Here the choice turns on whether you want the charge fixed or measured, and on how much metering you are prepared to authorise.

The multiple is not the same on every chain, because the two price lists fall at different rates. Across the six chains other than Ethereum the max quotes are almost flat — $0.25175 to $0.256125 — while the flash quotes vary by a factor of 3.5. The escalation multiple is 29.27 on Base, 34.03 on Arbitrum, 40.7 on Polygon and 100.7 on Avalanche, so the chain you settle on changes what an escalation costs by a factor of three. On Ethereum mainnet the quotes invert: $2.875 for qwen3.8-max against $3.75 for qwen3.8-flash. We report it as measured and do not account for it; an agent on mainnet routing on relative price would always choose the higher tier.

Treat both tables as reference points, not quotes. The amount in the 402 response is the amount you pay; under upto, the ceiling from that response governs, not the table.

What the ceiling actually does

The upto amount is not a second price. It is the most the call can cost at the max_tokens you authorise, so it moves with that allowance rather than with the work the call does. Table 3 measures it on Base with one short prompt, changing nothing but max_tokens.

Table 3. qwen3.8-flash and qwen3.8-max on Base: the upto ceiling at four output allowances, one short prompt, exact unchanged throughout. Source: measured 30 October 2026.

Set max_tokens deliberately. A call that leaves the field out authorises the model’s maximum output, and the flash ceiling on Base rises from $0.00875 at 1,000 tokens to $0.126708 with the field unset — about fourteen and a half times the figure in Table 1 — on a prompt that has not changed. The ceiling limits what a call can cost you; it does not forecast the bill.

How an agent uses it

Illustrative worked example. Take 1,000 calls a day, route 95% to qwen3.8-flash and escalate 5% to qwen3.8-max, settle on Base under exact, and use Tables 1 and 2. The figures illustrate the arithmetic; they are not a forecast for your traffic.

• Flash: 950 calls × $0.00875 = $8.3125 a day
• Max: 50 calls × $0.256125 = $12.80625 a day
• Total: $21.11875 a day
• At 30 days: $633.5625 a month, or $633.56

All-flash at the same volume:

• 1,000 × $0.00875 = $8.75 a day
• At 30 days: $262.50 a month

The escalation adds $12.80625 a day, more than the $8.3125 the other 950 calls cost. 5% of the calls carry 61% of the bill. A 5% escalation rate does not add 5% to the cost; it multiplies the bill by 2.4.

That trade is the whole decision. The escalation buys capability that cannot be measured from the outside — we publish no benchmark and make no claim that qwen3.8-max is more capable than qwen3.8-flash — so the rate has to be set from what the task requires and then checked against the feedback record. The escalation rate, not the per-call price, is the lever: at 10% the same 1,000 calls cost $1,004.63 a month, and at 20% they cost $1,746.75.

Three things make the rule explicit rather than accidental.

A trigger. Decide what sends a call to the higher tier before the first call. A task class, an output the agent can validate against its own schema, or a prompt the code knows to be hard, are all defensible; none requires a benchmark. What to avoid is a trigger inferred from a failed flash call: that path pays twice, $0.00875 for the attempt and $0.256125 for the retry.

A fallback. A flash call that cannot be escalated has to fail visibly. The endpoint is pay-per-call and retryable: build the retry in, and log which tier answered, so the split can be counted afterwards rather than assumed.

A cap. One escalated call costs as much as 29 flash calls. Express any budget cap in flash-call equivalents, so a loop that escalates is stopped at a known number of calls rather than found on the monthly statement.

Where it stops

Five limits matter before the first deployment.

No performance figures are published: no benchmark, latency, throughput or uptime figure, and no statement about streaming. This article asserts none of them. The price difference between the tiers is a fact about pricing, not evidence about capability, and we draw no conclusion from it. If those properties decide whether your agent is usable, measure them against your own traffic.

The figures are single-date quotes, read in one session on one day; the endpoint may price differently at another hour. No peak schedule is published here — unlike DeepSeek’s stated weekday windows — so we can neither include nor exclude a peak surcharge.

The prompt band is not published. Under exact the amount is fixed whatever the prompt; under upto the settled charge tracks measured tokens against a ceiling that, as Table 3 shows, rises with the max_tokens you authorise; how it behaves across prompt sizes is undocumented here. Log the 402 amount, the wall time and the outcome for the first few hundred calls, and compare them with these tables.

Model availability can change. The models offered are read from GET /v1/models for exactly that reason, and an agent that hardcodes a model name will break when that name goes away.

This is a pay-per-call endpoint, not a contracted service level. There is no SLA attached to a call. It is priced for a call that can fail and be retried, and belongs in a system that can absorb that.

When not to use it

Three cases where a different instrument is the right one.

You need a signed data-processing agreement. There is no account and no contract behind a call. If a reviewer, a client or a regulator expects a signed agreement governing the data you send, this endpoint will not satisfy that expectation, and should not be used for data that requires one.

You need a contracted service level. If your process requires an uptime commitment with defined measurement, credits or remedies, this endpoint carries none. Use it where a failed call is a retry, not where a failed call is an incident with a contractual consequence.

You need the cheapest possible call and cannot justify the max tier. If the workload is high-volume, low-stakes and uniformly easy, the second model is a cost with no matching benefit, and the routing machinery is another thing to maintain. Take qwen3.8-flash alone, at $0.00250 on Avalanche or $0.00875 on Base, and revisit if failures start to cluster.

How to start

Two requests, with one payment in between.

1. Call GET /v1/models. It is free. It returns the model names served right now — check that both tiers are listed — and confirms your base URL and network path are right before any money is involved.
2. Send POST /v1/chat/completions with a model and a messages array. The first attempt returns HTTP 402, with the amount due and the payment details for your chain. Every chain except Avalanche quotes a metered ceiling alongside the exact amount.
3. Pay the quoted amount in USDC, or in EURC on Base, from a wallet holding a small balance, then present the payment. The completion comes back on the retried request that carries it, not on the first one.

That is the whole handshake: ask, be told the price, pay, receive. Nothing to register, nothing to rotate.

Take the amount from the 402 response and pay that. Do not compute the charge from Table 1 or Table 2 and treat any difference as a fault. The tables are for budgeting; the handshake is for paying.

Size the float for the tier mix rather than the average. $5 of stablecoin holds 571 calls at the flash price, about 237 at a 95/5 split, and 19 if every call escalates. An agent funded for flash calls will stall the first time a run escalates once too often.

Method note

Prices read from the live 402 handshake on 30 October 2026, outside peak windows. The routing example in this article is arithmetic on those figures, not a measurement. The upto ceilings were measured the same day by varying max_tokens — 1,000, 8,000 and 32,000, then unset — on Base with the prompt held fixed.

Filed under Service Reviews · Tags: x402, inference, qwen, model-routing

Related reviews: DeepSeek review · HyperFusion review · SpiralStake review · Wolfram Alpha review · ElevenLabs review · Mage review

Background: what x402 is, and how a payment works

All seven reviews: the services reviewed

Marketplace: Qwen on x402.press — prices per chain, operations and the metered ceiling.