English
English
Cheap Claude API Key: What You Get and How to Check It
Key takeaways
- A cheap Claude API key is two things: a credential and a balance attached to it. It is not a model, and it does not tell you which capacity answers your call.
- What you can verify is the accounting. Three facts settle most of the question: does every call report token counts, does the deduction match those counts, and does a failed call leave the balance untouched.
- The whole test fits in about fifteen minutes: list the models the key can reach, send one Anthropic-protocol call, read its usage block, reconcile that same call in the usage record, force one failure, then repeat with a long cached prefix.
- If there is no per-call record, "cheap" is unproven rather than disproven. The missing ledger — not the low rate — is the reason to hold back volume.
What a key actually is
A credential is not a product. When you buy access to Claude through an aggregator, you receive a string that authenticates your calls against a balance that the operator holds. Everything else — which models answer, which capacity serves them, how a token is priced — is decided on the other side of that string.
That is why the first question about a cheap key is not "how low is the rate" but "what will this key let me see". A key that produces a per-call record is a key you can audit. A key that only produces a monthly total asks you to trust a number you cannot decompose.
The key also has to speak the right protocol. Claude Code and the Anthropic SDKs use one request shape; Cursor, Cline and most OpenAI-compatible clients use another. Both can be served by the same account, but they are not the same endpoint:
| Protocol family | Request path | Credential travels in | Typical clients |
|---|---|---|---|
| Anthropic-compatible | /v1/messages | x-api-key header | Claude Code, Anthropic SDK |
| OpenAI-compatible | /v1/chat/completions | Authorization: Bearer | Cursor, Cline, Cherry Studio, most SDKs |
How to check: before changing anything in a client, confirm which family that client uses. Pasting an Anthropic key into a base URL that only serves the OpenAI shape is the single most common "the key does not work" report — the key is fine, the endpoint is not the one the client speaks.
The fifteen-minute acceptance test
You do not need a trial period or a support ticket. You need the key, a terminal, and about fifteen minutes. Run the six steps in order; each one produces evidence for the next.
1. Ask the key what it can reach. Call the model list endpoint with your key. A normal answer is a list of model identifiers. An empty list or an authentication error is your first real finding: the credential exists, but nothing is attached to it.
2. Send one minimal call. Use the Anthropic-compatible path with a small max_tokens and a one-line prompt. Take the model identifier from the list you just received rather than from a blog post or a screenshot — model identifiers age faster than documentation does. What you are looking for is not the answer text; it is the response envelope.
3. Read the usage block in that response. A compliant response reports the input and output tokens it counted, and — on calls that touch a cache — separate fields for cache creation and cache reads. A first, short call will usually show no cache figures at all. That is expected, and it matters later.
4. Reconcile the same call in the usage record. Find that one request in the platform's usage view. Compare two things against step 3: the token counts, and the amount deducted for that request. This is the step that separates an auditable service from a plausible one, because it is the only place where price and usage meet in a single row.
5. Force one failure, then check the balance. Send a call with a model identifier that cannot exist. It will error. Now look for that request in the usage record. On KuaiAPI, failed requests are not billed — that is a published commitment, which makes it a claim you can test in one minute instead of a favour you hope for.
6. Repeat step 2 with a long, identical prefix. Send the same long block of context twice in a row. The second call is where a cache should show up as cache read tokens, priced differently from fresh input. Prompt caching is where most of the difference between a cheap endpoint and an expensive month is decided, and it is invisible unless you look for it.
What your result actually means
The test produces one of five outcomes. They call for different actions, and only the first one justifies scaling up.
| What you observed | What it means | What to do next |
|---|---|---|
| Per-call record matches the response's token counts and deduction | Usage and billing agree; the ledger is auditable | Compare structure across providers, then scale volume if the rate holds |
| No per-call record, or a total that cannot be decomposed | Nothing here can be verified, including the cheap rate | Treat it as unproven and keep volume small |
| A failed call appears as a charge | It contradicts a commitment the provider published | Raise it in writing before sending more traffic |
| Cache read tokens never appear on repeated long prefixes | Caching is not happening, so "cheap" is being decided somewhere else | Check prefix stability and the provider's cache minimum for that model |
401 or 403 on every call | The credential or the endpoint does not match the protocol family | Fix the header and base URL first; the key is probably fine |
How to check the last row quickly: switch only one thing at a time — header first, then path. Changing both at once hides which one was wrong, and a working key gets blamed for a configuration error.
Three habits that keep the test meaningful
One key per client. A single shared key makes the usage record unreadable: agent traffic, a notebook experiment and a production job all arrive under one identifier. Separate keys cost nothing and turn the ledger into something you can actually attribute.
Rotate anything that has been exposed. A key pasted into a repository, a chat message, a log line or a screenshot is compromised even if nobody has used it yet. Rotation is a two-minute action, and it is the cheapest security control available to you.
Keep credentials out of files you commit. Claude Code reads its endpoint and credential from environment settings and its own settings files rather than from your source tree — the official settings documentation lists the exact variables and their precedence. That is also why the acceptance test above works the same way in a terminal and inside an editor.
FAQ
Is a cheap Claude API key different from an official one? The request shape is the same, which is why existing SDKs and clients work after a base URL change. The difference is on the other side: who holds the upstream relationship, and whether what you received is documented well enough to be checked. One is a compatibility question, the other an accounting question.
Can I test a key before spending anything meaningful? Yes. Listing models is free, and the calls in this test are deliberately tiny. The cost of the test is far below the cost of discovering the answer after a month of production traffic.
Why do repeated calls not show cache tokens? Usually because the shared prefix is too short to qualify, or because it changed by even a character between calls. Every model family defines its own minimum length, so check the current documentation for the model you use rather than assuming a universal number.
Do I need a different endpoint for Claude Code? Claude Code speaks the Anthropic protocol, so it points at the host without the /v1 suffix, while OpenAI-compatible clients point at /v1. Both are served by the same balance and the same key.
Next step
The two pages that answer most remaining questions before you commit traffic are public and need no login. The model plaza lists per-model rates and the group multipliers they are derived from, so you can decompose a price instead of comparing a headline. The status page shows how each group is behaving right now, including when it is not behaving well.
For the surrounding decisions, Is a Cheap Claude API Reseller Safe? covers the checks worth running before you pay anyone, Claude Code base_url covers the client-side switch in detail, and What Is an AI API Aggregator? covers the operator-level questions. The English documentation covers endpoint and credential configuration, and the refund page states the process and its turnaround in writing.