← Volver a las guías

GPT-6.1 Sol pay-as-you-go pricing on 59API explained

Why a month of AI usage feels unpredictable

Most developers meet AI costs the same way: a bill arrives, and the number is hard to explain. You were only chatting with a model, but the meter counted thousands of input tokens, a long output, and cached context you barely noticed. The problem is not that models are expensive in principle. The problem is that many pricing pages describe an average, while your real usage is a mix of short prompts, long files, retry loops and long generated answers.

59API takes a different route. It is an independent third-party AI API relay, not an official channel, and it puts the meter in plain sight: one account, one API key, one API host at https://api.59api.com. You top up a prepaid balance, and each request is charged by real token usage. There is no monthly fee, and the balance never expires. So the question becomes concrete: if my month of GPT-6.1 Sol looks like this, what does it cost?

That is the right way to evaluate an API. Instead of guessing at a subscription, you can look at per-million-token rates, work through a realistic example, and see exactly where the money goes before you commit to anything larger.

What GPT-6.1 Sol costs per million tokens

GPT-6.1 Sol, model id gpt-6.1-sol, is priced per 1 million tokens on 59API at $0.1847 (¥1.33) for input, $0.9264 (¥6.67) for output, and $0.0375 (¥0.27) for cache read. For reference only, the official list price is $2 / $10 for input and output. 59API is not affiliated with OpenAI; the official list price is simply a comparison point, not a promise or an official channel.

Three lines, three jobs. Input tokens are what you send: system prompts, chat history, code you paste in, documents you retrieve. Output tokens are what the model writes back, and they carry the higher rate because generation is the expensive part of the request. Cache read tokens are context the service can reuse from a cache instead of processing fresh, and they are the smallest line of the three.

That last line deserves a second look. If your application sends the same large context repeatedly, cache reads can turn a recurring cost into a small one. If you are new to token pricing, the simplest mental model is still the first two: you pay for what you send and what you receive.

All prices are billed in CNY, with USD figures shown at ¥7.2 = $1, so you can read either currency without doing conversion maths in the middle of a project.

A month of traffic, priced out

Here is the worked example, and it is a plausible shape for a busy month: 5M input tokens plus 1M output tokens without cache. On 59API that comes to $1.85 (¥13.32). At the official list price of $20 (about ¥144), the same traffic would cost about 9% of list price on 59API.

Read that number again. Six million tokens of traffic, and the total is $1.85. That is the practical appeal of pay-as-you-go with a prepaid balance: there is no monthly fee to amortise, and there is no penalty for a light month. A week where you only ship a small feature costs what that week actually used, and a week where you run heavy batch jobs costs what those jobs consumed.

For comparison, GPT-5.6 Sol, model id gpt-5.6-sol, at 2M input plus 0.5M output tokens without cache is $1.67 (¥12) on 59API, versus $18 (about ¥129.6) at official list price, again about 9% of list price. So if your team is weighing two GPT models, the method is the same: pick the rates, then apply them to the traffic you already know you will send.

Connecting the calls and paying for them

Rates are only useful if the calls land. For GPT models, 59API works with Codex, OpenAI SDKs, cURL and OpenAI-compatible clients such as Cursor, Cherry Studio, Cline and OpenCode. Point your client at base URL https://api.59api.com/v1 and the chat endpoint https://api.59api.com/v1/chat/completions, then send your key.

The same account and key also serve DeepSeek and other non-Claude, non-Gemini models, so you can compare models without rewriting your stack. One host, one credential, one place to check usage.

Before you call anything, top up. Prepaid amounts are ¥10, ¥50, ¥100, ¥200, ¥500 and ¥1000, paid by WeChat Pay or bank card, and invoices are available. Start small if you like: the ¥10 top-up is enough to make a first request and watch real usage appear, and because the balance never expires, an unused top-up is not a deadline you have to rush.

There is no monthly fee and no commitment. What you spend depends on the tokens your application actually consumes, which is exactly what a pay-as-you-go model should promise: light months stay light, and heavy months are metered rather than billed by guesswork.

When a monthly or weekly card makes sense

Cards are optional. If your usage is heavy and predictable, a monthly or weekly card can be worth a look; if it is light or bursty, the prepaid balance is simpler. A card has its own key, can only call that family's models, and is paid only from the card: it never falls back to wallet balance, and a balance key never draws on a card. Unused quota does not roll over.

For GPT, the G-PRO Standard plan for 30 days is $160.42 (¥1155), with quota $6500 and a weekly cap $2500. It drains at the card's metering price × 2.4, and its reference value at official list prices is about $1805.56 (¥13000). The weekly option, G-PRO $1500 for 7 days, is $40.56 (¥292), with quota $1500 and a weekly cap $1500, and a reference value at official list prices of about $416.67 (¥3000).

One caveat worth repeating: card quota and caps are card metering units written in $, not official list-price dollars, so do not convert them into official prices. Cards also come in monthly and weekly forms, so you can match the term to the work.

Either way, the decision is the same: start with pay-as-you-go, watch your real token usage, and move to a card only when the numbers say so. Try 59API at https://59api.com, top up what you are comfortable with, and let the meter tell you what GPT-6.1 Sol really costs your project.

Docs