Summary
- Free tiers typically cap requests or tokens per period; pay-per-token keys meter what you actually use.
- This service charges $0.15 per 1M input tokens and $0.50 per 1M output tokens, prepaid.
- A chatbot with 20,000 requests a month at 3,000 input and 600 output tokens costs $15.00.
- For Groq or xAI prices, check their current pricing pages; this service is not affiliated with either.
Two ways a key can be billed
Almost every LLM API key falls into one of two models, and mixing them up is the main source of surprise bills and surprise cut-offs.
Capped free tier. The provider gives you a key at no charge and limits how much you can use it, usually by requests or tokens per minute or per day. It costs nothing until you hit a cap, and then the work stops or slows. Exact limits change, so check the provider's own pricing and limits page; we do not list another company's numbers here.
Pay per token. You load credit, every request draws it down by the tokens used, and there is no daily cap beyond technical rate limits. Cost scales with use, which makes it predictable once you know your token counts.
A free tier suits a weekend experiment. Per-token billing suits anything that has to keep running. Some providers offer both, with the free tier as a lead-in.
Before you rely on any free tier, ask five questions. What is the cap, per minute and per day? Does the cap apply to requests, tokens or both? What happens at the cap: an error, a slowdown or a block until tomorrow? Can the terms change without notice? And what does the next step up cost? The answers tell you whether the free tier is a test bench or a foundation. If the next step is a jump to a plan you do not want, you may prefer a metered key from the start.
What a key costs on this service
Pricing here is flat and short enough to memorise:
- $0.15 per 1M input tokens.
- $0.50 per 1M output tokens.
- Prepaid credit, no subscription, and credit never expires.
- Failed or refused requests are not charged.
- Top-ups of any whole amount from $20 to $500, with +5% from $50, +10% from $100 and +15% from $200.
New users can try it first: a one-click $0.50 trial on the API key page, valid for 7 days, no card, one per person. The service is not Groq, not xAI and not a router; it is one open-weight text model run by an independent provider and tuned to answer without content refusals for lawful adult use.
The formula
Cost per request is simple arithmetic:
cost = input_tokens x 0.15 / 1,000,000 + output_tokens x 0.50 / 1,000,000
Output tokens cost a little over three times as much as input tokens ($0.50 against $0.15), so long replies dominate the bill when prompts are short, and long prompts dominate when replies are short. Both show up in the usage block of every response, and the X-Balance-USD header shows what is left after each call.
To estimate tokens before you have measured any, use a rough rule for English: one token is about four characters, or three quarters of a word. A 1,000-word article is therefore about 1,333 tokens, which costs $0.0002 as input ($0.15 x 1,333 / 1M) and $0.000667 as output. Treat that as a guide only. Other languages, code and unusual formatting use more tokens per word, so check the real figure in the response.
Worked monthly costs
These examples use round numbers so you can substitute your own.
| Workload | Per request | Monthly volume | Monthly cost |
|---|---|---|---|
| Small script: 1,500 in, 400 out | $0.000425 | 30,000 requests (1,000 a day) | $12.75 |
| Chatbot: 3,000 in, 600 out | $0.00075 | 20,000 requests | $15.00 |
| Batch job: 5M in, 1M out in total | n/a | one run | $1.25 |
| Long-context call: 100,000 in, 1,000 out | $0.0155 | 1,000 requests | $15.50 |
Check the first row: 1,500 x 0.15 / 1M = $0.000225, plus 400 x 0.50 / 1M = $0.0002, for $0.000425. Multiply by 30,000 and you get $12.75. The chatbot: 3,000 tokens in cost $0.00045 and 600 tokens out cost $0.0003, so $0.00075 per request, and 20,000 requests cost $15.00. The batch job: 5M in is $0.75 and 1M out is $0.50, for $1.25. The long-context row: 100,000 tokens in is $0.015, and 1,000 out is $0.0005, so $0.0155 per call.
The last row matters if you plan to use the full 100,000-token context window. Filling it is cheap per call but adds up in a loop, so trim the history you resend.
When a free tier is the better choice
Being honest about this helps you pick well. If your usage is a handful of requests a day, a provider's free tier may cost nothing and be entirely enough. If you only need a famous vendor's specific model, a key for that vendor is the right tool; this service has one model only. And if you cannot pay in crypto, note that top-ups here are crypto only, USDT on TRC20 or USDC on Base.
Pay per token starts to win when you need steady throughput without daily caps, a long context, or text that the usual hosted chat products tend to refuse. A full key allows 8 concurrent requests and 300 requests per minute, and the trial key allows 2 and 60. The pricing page shows the current top-up options, and the documentation lists the rate-limit headers.
Many people end up using both. They build and test on a free tier, then switch the heavy or long-running parts to a metered key. Because this API is OpenAI-compatible, switching is a change to the base URL, key and model name, nothing more.
Reading the usage block and tracking spend
Every completion returns a usage object with the number of prompt and completion tokens. Multiply by the two prices and you have an exact cost per call, with no estimation needed. This small helper does it and logs the result:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.grokkey.com/v1",
api_key=os.environ["API_KEY"],
)
IN_PRICE = 0.15 / 1_000_000 # dollars per input token
OUT_PRICE = 0.50 / 1_000_000 # dollars per output token
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a 150-word product blurb for a candle shop."}],
)
u = resp.usage
cost = u.prompt_tokens * IN_PRICE + u.completion_tokens * OUT_PRICE
print(f"{u.prompt_tokens} in, {u.completion_tokens} out, ${cost:.6f}")Sum those figures per app or per user, and you can answer the question that a flat plan never lets you answer: what does each feature actually cost? You can cross-check against the X-Balance-USD header or GET /v1/balance.
Keeping the bill small
- Trim history. Resending a full conversation each turn multiplies input tokens. Summarise older turns once they pass a few thousand tokens.
- Set
max_tokenswhen you need short answers. It is optional, but it stops a rambling reply from running up output cost. - Keep system prompts short. A 300-token system prompt costs $0.000045 per request. Across 100,000 requests that is $4.50.
- Use separate keys. After a top-up you can hold up to 5 keys with labels, so you can tell which app is spending. Compare with a Claude key in our Claude API key versus GrokKey article.
Setting a monthly budget
With prepaid credit, the budget is the balance. If you decide that a project may spend $15.00 a month, load only that, and the worst case is bounded. Some practical rules of thumb follow from the maths above.
- Each additional $1.00 of credit buys about 6.67 million input tokens or 2 million output tokens.
- A $20 top-up, the minimum, covers about 26,666 requests of the chatbot shape ($20 / $0.00075) or about 47,058 of the small-script shape ($20 / $0.000425). The counts differ because the requests differ, so measure your own.
- With the top-up bonuses, $100 loads $110 and $200 loads $230 of credit.
Since credit does not expire, the cost of overbuying is only that your money sits waiting. If you are unsure, start with the minimum and see how fast the balance drops over a week.
