Grok 4.6 API relay pricing: what to check before paying CheapRelay

01 / Grok 4.6 pricing on CheapRelay, broken into three numbers

Before you pay for an API relay, check the price of all three billable lines: input tokens, output tokens, and cache-read tokens. CheapRelay lists Grok 4.6 at $0.4653 per 1,000,000 input tokens, $1.39 per 1,000,000 output tokens, and $0.1167 per 1,000,000 cache-read tokens. The model id to enter is grok-4.6.

That is the whole Grok 4.6 price list. There is no subscription to calculate, no seat count, and no monthly commitment to amortize. CheapRelay uses a prepaid balance and charges per real token, with no monthly fee. The balance does not expire, so unused money stays available for later work.

Here is an example. Send 1,000,000 input tokens and request 200,000 output tokens:

• ■ Input: 1,000,000 × $0.4653 per million = $0.4653
• ■ Output: 200,000 × $1.39 per million = $0.2778
• ■ Example total: $0.4653 + $0.2778 = $0.7431

Now the same arithmetic with a larger job: 10,000,000 input tokens, 2,000,000 output tokens, and 5,000,000 cache-read tokens.

• ■ Input: 10 × $0.4653 = $4.653
• ■ Output: 2 × $1.39 = $2.78
• ■ Cache read: 5 × $0.1167 = $0.5835
• ■ Example total: $4.653 + $2.78 + $0.5835 = $8.0165

That example cost is easy to audit before the first request leaves your machine.

02 / How Grok 4.6 compares with nearby price-list rows

Because the price list does not show an official list price for Grok 4.6, a direct official-price saving would be a made-up number. Instead, compare the published CheapRelay rows with each other.

Start with Grok 4.7. Its input price is $0.5056, its output price is $1.52, and its cache-read price is $0.1264 per million. For the 10 million input, 2 million output, and 5 million cache-read example above:

• ■ Grok 4.7: 10 × $0.5056 + 2 × $1.52 + 5 × $0.1264
• ■ Grok 4.7 total: $5.056 + $3.04 + $0.632 = $8.728
• ■ Grok 4.6 total: $8.0165
• ■ Example difference: $8.728 − $8.0165 = $0.7115

On this example, Grok 4.6 costs about 8.2% less than Grok 4.7. That difference comes from all three lines: $0.5056 is above $0.4653, $1.52 is above $1.39, and $0.1264 is above $0.1167.

Next, compare output pricing with GLM-5.3. GLM-5.3 lists output at $1.38 per million, while Grok 4.6 lists $1.39. On 2,000,000 output tokens, GLM-5.3 costs $2.76 and Grok 4.6 costs $2.78, a difference of $0.02. Input and cache-read pricing still apply separately, so use the row that matches the whole workload rather than one line alone.

Gemini 2.5 Flash has a listed output price of $1.42 per million, compared with Grok 4.6 at $1.39. For 2,000,000 output tokens, that is $2.84 versus $2.78. Again, this is an output-only example, not a claim about a complete mixed workload.

03 / Where cache reads change the bill

Cache reads deserve their own line because they are priced at $0.1167 per million on Grok 4.6. Compare that with the $0.4653 input rate: $0.1167 ÷ $0.4653 = 0.2508, so a cache-read million costs about 25% of an input million.

Example: one million input tokens, one million output tokens, and one million cache-read tokens.

• ■ Without a cache read: $0.4653 + $1.39 = $1.8553
• ■ With one million cache-read tokens: $0.4653 + $1.39 + $0.1167 = $1.972
• ■ Example cache-read line: $0.1167

The output rate is the largest line in that example. In fact, $1.39 ÷ $0.4653 is about 2.99, so a million output tokens cost roughly three times a million input tokens. Output-heavy jobs deserve a closer look at the $1.39 figure.

Scale the same example to 20 identical runs: 20 × $1.972 = $39.44. One hundred runs cost 100 × $1.972 = $197.20. These are examples, not quotes for a particular application, but they show how the three rates combine into a budget you can calculate in advance.

CheapRelay also gives every new account $0.09 in sign-up credit, usable on any model. That is not much on its own, but it is usable credit rather than a demo limitation tied to one model.

04 / Connecting Grok 4.6 without guesswork

Grok uses the OpenAI-compatible route under /v1. The CheapRelay API base is https://api.cheapapirelay.com. That route supports Grok and other OpenAI-compatible models through clients such as Cursor, Cherry Studio, Cline, Roo Code, OpenCode, the OpenAI SDK, or cURL.

The setup is straightforward: create an account, add prepaid funds, use the base URL above, select an OpenAI-compatible client, and enter grok-4.6 as the model id. The per-token rates then follow the same three-line calculation shown above.

There are two operating limits worth checking. Each key is limited to 120 calls per minute, and each account can have 8 calls running at once. If you receive HTTP 402, the account balance is at or below zero. Top up the prepaid balance before continuing.

There is no monthly fee to carry while you test the numbers. You can begin with a small balance, watch the actual token usage, and compare it with the published rates. If a request does not look right, the arithmetic is already visible: multiply each token count by the matching rate and add the three lines.

05 / Balance safety, referrals, and the final bill

CheapRelay also publishes the practical rules around the balance. Unused balance can be refunded within 12 days of a top-up, minus what has already been spent and the payment fee. The balance itself does not expire. Together, those terms let you size a top-up around a specific example instead of buying a fixed monthly commitment.

The referral program adds another line to the economics. A directly invited user contributes 20% of what they pay, while the second level contributes 6%. Those amounts go into a withdrawable rewards balance. The smallest withdrawal is ¥20, paid through Alipay.

Put the final example together. A run with 10,000,000 input tokens, 2,000,000 output tokens, and 5,000,000 cache-read tokens costs $8.0165 on Grok 4.6 at CheapRelay. The same token counts cost $8.728 on Grok 4.7, a difference of $0.7115. A smaller run with 1,000,000 input tokens and 200,000 output tokens costs $0.7431.

Those are examples, but the inputs are simple: $0.4653 for input, $1.39 for output, and $0.1167 for cache reads, each per 1,000,000 tokens. Check those three numbers, count your tokens, and the API relay bill becomes a multiplication rather than a mystery.