← Voltar aos guias

GPT models on 59API API relay: per-token rates compared

Choosing a GPT model without a pricing mystery

Most developers hit the same wall: the model list says GPT, but the bill is a mystery. Input tokens, output tokens and cache reads are priced separately, and the headline number rarely tells you what a real request will cost. Then there is the account problem. Separate provider dashboards, separate keys, separate top-ups, more administration than engineering.

59API removes that overhead with one account and one API key across Claude, GPT, Gemini, DeepSeek and other models. You pay from a prepaid balance, charged per request by real token usage. There is no monthly fee, and your balance never expires. Monthly and weekly cards are optional if you prefer them, but the default path is simple: top up, point your client at one API host, and watch actual usage.

For GPT specifically, 59API currently lists three models with published per-million-token rates: GPT-5.6 Sol, GPT-6 Astra and GPT-6.1 Sol. That is a small, readable list. You can compare input, output and cache-read prices line by line before writing a line of code, then switch models by changing one model id rather than rebuilding your billing setup.

One important note: 59API is an independent third-party AI API relay. Official list prices quoted here are reference points for comparison, not a claim that 59API is an official or authorised channel.

The three GPT models and their exact rates

All prices below are per 1 million tokens. Billing is in CNY, and the USD figures are shown at ¥7.2 = $1.

• GPT-5.6 Sol (model id gpt-5.6-sol): input $0.3472 (¥2.5), output $1.94 (¥14), cache read $0.0278 (¥0.2); official list price $4 / $20 (OpenAI promotional price, at least through 2026-11-21).
• GPT-6 Astra (model id gpt-6-astra): input $0.6944 (¥5), output $3.47 (¥25), cache read $0.0694 (¥0.5); official list price $10 / $50.
• GPT-6.1 Sol (model id gpt-6.1-sol): input $0.1847 (¥1.33), output $0.9264 (¥6.67), cache read $0.0375 (¥0.27); official list price $2 / $10.

Read the table twice, because the shape of the pricing matters more than any single headline figure. Output is always the expensive column, so a chat product that generates long replies is driven by output volume. Input is cheaper, but it is the column that grows with large system prompts and retrieved context. Cache read is cheaper again, and it is where a well-structured prompt can quietly reduce your bill.

The practical takeaway: pick the model whose output rate matches your response length, rather than choosing on input price alone. A short, structured answer on GPT-6.1 Sol can cost less per request than a verbose one on GPT-5.6 Sol.

Two worked examples with real token volumes

Numbers beat adjectives, so here are two concrete runs through the 59API rate card, both without cache.

• GPT-6.1 Sol, 5M input + 1M output tokens: $1.85 (¥13.32) on 59API. At the official list price the same run costs $20 (about ¥144), so 59API is about 9% of list price.
• GPT-5.6 Sol, 2M input + 0.5M output tokens: $1.67 (¥12) on 59API. At official list price the same run costs $18 (about ¥129.6), so 59API is about 9% of list price.

These are hypothetical workloads, but they show how the arithmetic works in practice. Multiply your expected input tokens by the input rate, multiply expected output tokens by the output rate, and add them. Because 59API bills by real token usage, that estimate is what you are actually approximating, not a seat fee or a subscription you might forget to cancel.

Two details make the estimate tighter. First, cache reads are billed separately and cheaply, so if your prompt repeats across calls, the cached portion is not billed as fresh input. Second, prepaid balance means you can start with a small top-up, measure one real request, and adjust before committing to a larger workflow.

Where GPT-6 Astra fits in the lineup

GPT-6 Astra sits between the two Sol models on input and above both on output: input $0.6944 (¥5), output $3.47 (¥25), cache read $0.0694 (¥0.5), against an official list price of $10 / $50. That makes it the option to evaluate when a task benefits from more expensive generation but you still want predictable, published rates on 59API.

The comparison is straightforward. GPT-6.1 Sol has an input rate of $0.1847 (¥1.33) and an output rate of $0.9264 (¥6.67), both under the equivalent rates on GPT-5.6 Sol. GPT-5.6 Sol has input $0.3472 (¥2.5) and output $1.94 (¥14). GPT-6 Astra has input $0.6944 (¥5) and output $3.47 (¥25). If your workload is dominated by long context, the input column dominates. If it is dominated by long generated answers, the output column dominates.

Because all three share one key and one host on 59API, you can run the same prompt against each model id, compare the real bills in your own dashboard, and keep the winner. That is a far more useful test than a pricing table alone, and it costs you only the tokens you actually use.

Connecting GPT models to your own code

GPT models on 59API work with Codex, OpenAI SDKs, cURL and OpenAI-compatible clients such as Cursor, Cherry Studio, Cline and OpenCode. The settings are short enough to paste straight into your environment.

• Base URL: https://api.59api.com/v1
• Chat endpoint: https://api.59api.com/v1/chat/completions
• API key: your 59API key, stored as YOUR_59API_KEY

Switching models is a single field. Set the model to gpt-5.6-sol, gpt-6-astra or gpt-6.1-sol and the rest of your request stays the same. That is the practical benefit of one API host: pricing experiments do not require new SDK code, new credential handling or a second billing relationship.

Funding is equally direct. Top-ups come in ¥10, ¥50, ¥100, ¥200, ¥500 and ¥1000, paid by WeChat Pay or bank card, with invoices available. There is no monthly fee, and unused balance never expires, so a small test top-up is a low-commitment way to start. Once you see real usage, you can raise the balance or move to a card.

GPT cards when you want a fixed monthly spend

Some teams prefer a predictable envelope to a variable balance. 59API offers optional GPT cards, each with its own key, each restricted to the GPT family, and each paid only from the card itself. A card never falls back to wallet balance, and a balance key never draws on a card. Unused quota does not roll over.

• G-PRO Starter (GPT, 30 days): $83.19 (¥599); quota $3250, weekly cap $1250; drains at the card metering price × 2.4; reference value at official list prices about $902.78 (¥6500).
• G-PRO Standard (GPT, 30 days): $160.42 (¥1155); quota $6500, weekly cap $2500; drains at the card metering price × 2.4; reference value at official list prices about $1805.56 (¥13000).
• G-PRO Flagship (GPT, 30 days): $259.03 (¥1865); quota $11000, weekly cap $4000; drains at the card metering price × 2.4; reference value at official list prices about $3055.56 (¥22000).

There is also a weekly option, 【周卡】G-PRO $1500 (GPT, 7 days): $40.56 (¥292); quota $1500, weekly cap $1500; drains at the card metering price × 2.4; reference value at official list prices about $416.67 (¥3000). Card quota and caps are metering units written in $, not official list-price dollars, so treat them as card capacity rather than a promise about official pricing.

Which route fits? Pay-as-you-go from the prepaid balance if you want flexibility and usage that tracks real traffic. Take a card if you want a fixed 30-day or 7-day envelope for a team. Either way, the GPT rates on 59API stay visible, the billing stays in token terms, and your first step is the same: top up, set the base URL, send one request and read the actual cost.

Docs