OpenCode API relay: $10.00 official list, $0.7375 per 1M

01 / From an empty CheapRelay account to a funded balance

OpenCode is comfortable in the terminal, so the sensible place to start is with the bill rather than the editor. CheapRelay charges for real tokens used by a request, which means there is no monthly fee and no need to guess which fixed allowance will fit your week. Create an account at cheapapirelay.com, and every new account receives $0.09 in sign-up credit that can be used on any model.

That credit is enough to make a small test call before you commit meaningful money. When you are ready for regular work, add funds to the prepaid balance. The balance does not expire, so an unused top-up is not a subscription that quietly drains away. You are paying for the calls you actually make.

The refund rule is straightforward too: unused balance can be refunded within 12 days of the top-up, minus what has already been spent and the payment fee. That makes it easier to treat the first balance as a measured trial. Put in a small amount, run the task you actually have in mind, then look at the resulting token usage before scaling up.

• ■ New-account credit: $0.09, usable on any model.
• ■ Billing: prepaid balance, charged per real token.
• ■ No monthly fee, and the balance does not expire.
• ■ Refunds for unused balance within 12 days, less spending and the payment fee.

For a developer who wants to price a task before running it, that is the whole financial setup: one account, one balance, and usage that can be checked after the call.

02 / Why GPT-6.1 Sol is a practical OpenCode choice

The client and model have to agree on the protocol. OpenCode is an OpenAI-compatible client and works with GPT models through the /v1 route. That makes GPT-6.1 Sol a direct fit. The model id to enter is gpt-6.1-sol.

Now look at the price list instead of accepting the official list price as the only option. GPT-6.1 Sol is listed at $0.1486 per 1 million input tokens, $0.7375 per 1 million output tokens, and $0.0347 per 1 million cache-read tokens. The official list prices for the same model are $2.00 input, $10.00 output, and $0.10 cache read.

The output arithmetic is the headline: $10.00 minus $0.7375 is $9.2625, and $9.2625 divided by $10.00 is 92.625%. Rounded to a whole percentage, that is 93% under the official list price. For input, $2.00 minus $0.1486 is $1.8514, which is 92.57% below the official list. For cache reads, $0.10 minus $0.0347 is $0.0653, or 65.3% below the official list.

It is worth keeping the client boundaries clear. Claude models on CheapRelay are only for the official Claude Code and Claude Desktop clients, version 2.1.285 or newer, not OpenCode. Gemini models use the native protocol under /v1beta through Gemini CLI, also not OpenCode. GPT, DeepSeek, Kimi, GLM, Qwen, Grok, MiniMax and the other OpenAI-compatible models can be used with OpenCode under /v1. For this walkthrough, GPT-6.1 Sol keeps the path short.

03 / Point OpenCode at the CheapRelay base URL

Once the account has credit, the configuration is small. In OpenCode, create a provider entry for an OpenAI-compatible service, then fill in three values: the API base URL, the account key, and the model.

• ■ API base URL: https://api.cheapapirelay.com/v1
• ■ API key: the key created in your CheapRelay account
• ■ Model id: gpt-6.1-sol

Send a short prompt first, such as asking the model to summarize one small file. That first request confirms three things at once: the base URL is reachable, the key is accepted, and the model id resolves. Because CheapRelay bills against real token usage, even this small request produces a measurable amount rather than a flat monthly charge.

There are two operational limits to keep in view. Each key can make 120 calls per minute, and each account can have 8 calls running at once. Those limits are useful for terminal workflows because they define the shape of a busy session without adding another pricing plan. If a request returns HTTP 402, the account balance is at or below zero. That is a funding signal, not a mysterious model failure.

For a larger task, the same three values remain unchanged. You are not switching gateways between a test and a production-sized prompt; you are changing the work while keeping the terminal client and the billed account in place.

04 / The first billed call, with the arithmetic

Here is an example task: 10,000 input tokens, 2,000 output tokens, and 50,000 cache-read tokens. Using the GPT-6.1 Sol prices on the price list, the input cost is 0.01 multiplied by $0.1486, which is $0.001486. The output cost is 0.002 multiplied by $0.7375, which is $0.001475. The cache-read cost is 0.05 multiplied by $0.0347, which is $0.001735. Adding them gives $0.004696 for that example request.

That is the useful part of per-token billing: the example is not a package price. It is a calculation you can repeat with the real token counts from your own session. More context means more input tokens; a longer answer means more output tokens; reused context can arrive through cache reads at $0.0347 per 1 million.

Now scale the example to 1 million input tokens and 1 million output tokens, with no cache reads. On CheapRelay, $0.1486 plus $0.7375 equals $0.8861. At the official list prices, $2.00 plus $10.00 equals $12.00. The example difference is $11.1139 for the same token volumes, and $11.1139 divided by $12.00 is 92.6158%.

This is not a promise that every task uses one million tokens. It is a way to price a heavy task in advance. When a background job, a long refactor, or an agentic loop starts consuming tokens quickly, the arithmetic tells you what the scale is before the balance moves.

05 / What the rest of the price list looks like in practice

GPT-6.1 Sol is not the only option for OpenCode, so it helps to compare actual rows. Qwen3.7 Plus, with model id qwen3.7-plus, is priced at $0.1208 input, $0.3625 output, and $0.0361 cache read. MiMo V2.6 Pro, with model id MiMo-V2.6-Pro, is priced at $0.1736 input, $0.3472 output, and $0.002778 cache read.

In an example using 1 million input tokens and 1 million output tokens, Qwen3.7 Plus costs $0.1208 plus $0.3625, or $0.4833. MiMo V2.6 Pro costs $0.1736 plus $0.3472, or $0.5208. The difference in that example is $0.0375. The two rows also point in different directions: Qwen3.7 Plus has the lower input figure, $0.1208 against $0.1736, while MiMo V2.6 Pro has the lower output figure, $0.3472 against $0.3625, and the lower cache-read figure, $0.002778 against $0.0361.

The GPT family also shows how wide the range can be. GPT-5.6 Sol, model id gpt-5.6-sol, is listed at $0.3056 input, $1.71 output, and $0.0264 cache read, against official list prices of $4.00, $20.00 and $0.40. Its output price is 91% under the official list. GPT-6 Astra, model id gpt-6-astra, is listed at $0.5639 input, $2.82 output, and $0.0569 cache read, against official list prices of $10.00, $50.00 and $1.00, putting output 94% under the official list.

That range is the point of working from a price list. CheapRelay does not ask you to buy one tier for every kind of task. You choose the model that fits the job, and you pay for the tokens that job uses.

06 / Keeping the terminal workflow inexpensive

CheapRelay also returns part of the acquisition cost through referrals. A directly invited user contributes 20% of what they pay, and the second level contributes 6%. Those amounts go into a separate withdrawable rewards balance, with the smallest withdrawal set at ¥20 through Alipay. That is an addition to the usage-based pricing, not a replacement for it.

Put the pieces together and the OpenCode workflow is short: create the account, use the $0.09 credit for a test, top up the prepaid balance when the test looks right, point OpenCode at https://api.cheapapirelay.com/v1, and enter gpt-6.1-sol. The first billed call then follows the arithmetic above, token by token, with no monthly fee in the way.

For a developer who wants to justify the spend before clicking run, the numbers are the convincing part. $0.8861 for the million-token example against $12.00 at the official list price, $0.004696 for the smaller example request, and a balance that does not expire. CheapRelay gives the terminal a price you can calculate before the task and verify after it.