← Retour aux guides

Codex API proxy: is 59API right for all-day developers?

The all-day Codex problem is a running meter, not a monthly bill

If you run Codex all day, cost stops being an abstract pricing page and becomes a running meter. Every refactor, every repeated context block, every long file read adds tokens, and the bill grows with the hours you actually work. The practical questions are simple: what does each request cost, how many accounts and keys are you juggling, and can a heavy day quietly turn into a heavy month?

59API is built for that shape of work. It is an independent third-party AI API relay: one account, one API key, one API host at https://api.59api.com, serving GPT, DeepSeek and other models you route through it. There is no monthly fee. You top up a prepaid balance, and every request is charged by real token usage. Your balance never expires, which matters when a quiet week is followed by a week of long Codex sessions.

Top-ups come in ¥10, ¥50, ¥100, ¥200, ¥500 and ¥1000, paid by WeChat Pay or bank card, and invoices are available. A first experiment therefore costs ¥10, while a demanding week can be funded without a recurring commitment.

Picture a hypothetical developer who keeps Codex open from morning to evening, alternating a stronger GPT model for architecture work with a lighter model for routine edits. With one key and one host, switching is a model ID change rather than a second billing relationship. That is the first reason 59API suits people who live inside Codex.

What one key and one prepaid balance actually change

Most of the friction in an all-day workflow comes from plumbing, not from prompts. If you are switching providers, you are juggling separate keys, separate balances and separate dashboards. 59API collapses that into a single account, a single API key and a single host, so the same base_url and the same credential serve every model you call through it.

The billing model matters just as much. 59API charges per request based on real token usage, with prices listed per 1 million tokens and billed in CNY, with USD figures shown at ¥7.2 = $1. There is no monthly fee, and unused balance does not expire. Optional monthly and weekly cards sit alongside that wallet, but the wallet alone is a complete option for a developer who prefers to pay only for what is consumed.

For a hypothetical full-day Codex user, that combination is straightforward: keep one key in your environment, watch real usage, and top up when the balance gets low. Because balances carry no expiry, a small ¥10 top-up for a quiet weekend does not become dead money, and a larger ¥1000 top-up before a launch week does not need to be consumed on a deadline.

59API also supports invoices, which matters if your Codex usage eventually has to be expensed rather than absorbed into a personal card. And the referral programme exists if you introduce teammates: 15% commission on what people you invite pay for top-ups and cards, plus 5% on what their invitees pay, withdrawable to Alipay from ¥50 or moved straight into API balance.

The GPT numbers you would actually pay

Here is where an API proxy earns its place. 59API lists per-million-token rates for the models a Codex user is most likely to reach for, and the spread between them is wide enough to justify deliberate model choice.

• GPT-6.1 Sol (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.
• GPT-5.6 Sol (gpt-5.6-sol): input $0.3472 (¥2.5), output $1.94 (¥14), cache read $0.0278 (¥0.2). Official list price $4 / $20, an OpenAI promotional price at least through 2026-11-21.
• GPT-6 Astra (gpt-6-astra): input $0.6944 (¥5), output $3.47 (¥25), cache read $0.0694 (¥0.5). Official list price $10 / $50.

Two non-GPT options are also priced for heavy use. DeepSeek V4 Flash (deepseek-v4-flash) lists input $0.2778 (¥2), output $1.11 (¥8), cache read $0.006944 (¥0.05). MiniMax M3 (MiniMax-M3) lists input $0.1389 (¥1), output $0.5556 (¥4), cache read $0.0278 (¥0.2).

Cache reads deserve attention in a long Codex session, because repeated context is exactly where usage accumulates. At $0.0375 (¥0.27) per 1 million for GPT-6.1 Sol, cached context stays inexpensive relative to fresh input at $0.1847 (¥1.33). The lesson for an all-day user is straightforward: pick the model that matches the task, and let cache reads handle the repetition.

Worked examples: what a heavy session can cost

Numbers only become persuasive when they describe a realistic session. Consider a hypothetical session where Codex handles 5M input tokens and 1M output tokens without cache.

On GPT-6.1 Sol, that run costs $1.85 (¥13.32) through 59API. At the official list price of $20, the same usage is about ¥144, so 59API is about 9% of list price. A second hypothetical session, this time 2M input tokens and 0.5M output tokens on GPT-5.6 Sol, costs $1.67 (¥12) on 59API, against an official list price of $18, or about ¥129.6, making 59API about 9% of list price again.

Read those figures per session rather than per subscription. There is no monthly fee attached to them, and no expiry clock on whatever balance remains after the work is done. If your day is a sequence of comparable Codex sessions, the wallet simply tracks the sum of those sessions, and you decide when to add more funds.

One important caveat: official list price is only a reference price. 59API is an independent third-party relay, not an official channel, and the comparison is there to show the shape of the saving rather than to promise a rate that can move with the upstream provider.

For an all-day user, the practical conclusion is that model selection is a cost lever you control directly. Run heavy architectural work on the model you trust, route repetitive edits to a cheaper non-Claude, non-Gemini option such as DeepSeek V4 Flash or MiniMax M3, and let per-token billing keep the day proportional to the work you actually did.

Balance versus cards when you run Codex every day

If your Codex usage is steady and predictable, the prepaid balance is usually the cleanest option: top up, spend against real usage, keep the remainder. But when you want a fixed, metered allowance for a busy stretch, 59API offers optional cards with their own key and their own family of models.

Take the weekly G-PRO $1100 card: it covers GPT models for 7 days at $40.56 (¥292), with quota $1100 and a weekly cap $1100. Its reference value at official list prices is about $305.56 (¥2200). For a month-long pattern, G-PRO 入门版 (GPT, 30 days) costs $83.19 (¥599), with quota $2300 and a weekly cap $880, and a reference value at official list prices of about $638.89 (¥4600).

Four rules matter before you buy. A card has its own key and can only call that family's models. It is paid only from the card and never falls back to wallet balance, while a balance key never draws on a card. Unused quota does not roll over. And quota plus caps are card metering units written in $, not official list-price dollars, so they should not be converted into official prices.

All cards drain at the card's metering price × 2.4. So for someone running Codex all day every week, the decision is simple: if your usage is lumpy and you want to keep paying by the token, stay on the balance; if you want a predictable block of GPT capacity for a fixed window, a card gives you that structure. Either way, 59API keeps the same host and the same account underneath.

Connecting Codex, and who 59API suits

Setup is deliberately short. Codex, OpenAI SDKs, cURL and OpenAI-compatible clients such as Cursor, Cherry Studio, Cline and OpenCode work with GPT, DeepSeek and other non-Claude, non-Gemini models only. Point base_url at https://api.59api.com/v1 and the chat endpoint at https://api.59api.com/v1/chat/completions, then send your 59API key as the bearer credential. There is no second account, no second dashboard and no monthly fee to remember.

One boundary is worth stating plainly. Claude models work only through the genuine Claude Code or Claude Desktop client (Claude Code 2.1.285 or newer), never through the OpenAI SDK, cURL or other clients. Gemini models use Google's native protocol only, through Gemini CLI, and do not work on /v1/chat/completions. If your day is spent inside Codex, that is a constraint to plan around rather than a surprise to discover mid-session.

So who is 59API right for? The developer who keeps Codex open for hours and wants to pay per token instead of per subscription. The developer who alternates between a stronger GPT model and a cheaper one without managing several keys. The developer who wants a ¥10 starting point, a balance that never expires, invoices when needed, and optional cards when a fixed allowance suits the week better.

And the developer who simply wants one host to point at. Try 59API with a small top-up, set the base URL, and let the next full-day Codex session show you what it costs.

Docs