Space Bunny Alpha › API
Space Bunny Alpha API: Free OpenAI-Compatible Guide
Space Bunny Alpha is served through TokenRA's OpenAI-compatible API under the model ID space-bunny-alpha, and it is free to call right now — zero charge for both prompt and completion tokens during the preview. If your stack already speaks the OpenAI format, adoption is a two-line change: swap the base URL and the model slug. Below are working examples, the parameters that actually matter, and the fallback you should wire up before you depend on it.
Last updated 25 September 2026 · Released 23 September 2026 · Free preview in effect
Read this before you build on a free preview
Stealth models in this series have a consistent pattern: the model is free while anonymous, then the provider claims it and the free window closes. The most recent case, Ox Alpha, was free for about six days before Z.ai revealed it as GLM-5.3-Flash and ended the free listing. Two things follow:
- Keep the model ID in one config value, never scattered through your code, so switching to a named model is a one-line change.
- Configure a fallback model now, before you need it. A free preview is a great place to prototype and a bad place to have your only dependency.
How we label sources on this page
Anonymous models attract a lot of confident numbers. We separate what TokenRA states from what a third party has measured from what is only a hypothesis.
TokenRA is the API gateway used by the examples below. OpenRouter is a separate gateway listing used only for its own operational metrics. The same model codename appears on both pages, but no public source confirms that they share one upstream provider or one listing.
The essentials
| Item | Value |
|---|---|
| Model ID | space-bunny-alpha |
| Base URL | https://tokenra.io/v1 |
| API format | OpenAI-compatible (/chat/completions) |
| Authentication | Bearer token — your TokenRA API key |
| Price | Free (prompt and completion) |
| Context window | 1,000,000 tokens |
| Max output | 524,288 tokens |
| Input | Text, image, video |
| Output | Text |
| Reasoning | Adjustable reasoning effort |
| Tool calling | Supported |
| Structured output | response_format JSON, no schema enforcement |
| Provider / gateway | Anonymous third-party provider; TokenRA is the API gateway. Route topology and any fallback are not disclosed. |
Values above are from the TokenRA model page, snapshot 24 September 2026. Live figures such as throughput and availability change continuously and are tracked on our benchmarks page.
Step 1 — Get a key
Create a TokenRA account and generate an API key. Because this model is listed at zero price, the key does not need credit for this call — but keep in mind that a key which works today for free will start costing money the moment you point it at a paid model instead.
Store the key in an environment variable. Do not paste it into source files or commit it:
export TOKENRA_API_KEY="your_tokenra_key"
Step 2 — Make a call
curl
curl https://tokenra.io/v1/chat/completions \
-H "Authorization: Bearer $TOKENRA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "space-bunny-alpha",
"messages": [
{"role": "user", "content": "Explain what a 1M token context window means in practice."}
]
}'
Python (OpenAI SDK)
The OpenAI SDK works unchanged — only the base URL and model ID differ, which is the whole point of an OpenAI-compatible endpoint:
from openai import OpenAI
client = OpenAI(
base_url="https://tokenra.io/v1",
api_key=os.environ["TOKENRA_API_KEY"],
)
resp = client.chat.completions.create(
model="space-bunny-alpha",
messages=[{"role": "user", "content": "Summarise this changelog."}],
)
print(resp.choices[0].message.content)
JavaScript
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://tokenra.io/v1",
apiKey: process.env.TOKENRA_API_KEY,
});
const resp = await client.chat.completions.create({
model: "space-bunny-alpha",
messages: [{ role: "user", content: "Write a regex for ISO 8601 dates." }],
});
console.log(resp.choices[0].message.content);
Parameters that behave differently on this model
| Parameter | Behaviour | Practical advice |
|---|---|---|
tools / tool_choice | Function calling is supported | Standard OpenAI shape — agents work without adaptation |
response_format | JSON mode, but no JSON-schema enforcement | Validate the parsed JSON yourself; do not assume the shape |
| reasoning effort | Adjustable levels | Lower effort for bulk or latency-sensitive jobs; raise it for hard reasoning |
max_tokens | Ceiling is 524,288 | Cap it deliberately — the ceiling is high enough to produce runaway output |
| Image / video input | Accepted as content blocks | Multimodal input is real and adapter-class, not a placeholder |
An image input example
Vision on this model was independently characterised as adapter-class with size-scaled token overhead, meaning the encoder responds to actual image content rather than ignoring it. Sending an image uses the standard OpenAI content-block shape:
{
"model": "space-bunny-alpha",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "Describe what is wrong with this chart."},
{"type": "image_url", "image_url": {"url": "https://example.com/chart.png"}}
]
}]
}
Working with a 1M-token context
A million-token window is the headline capability, and it changes how you should structure a request:
- Put the instructions last, not first. On very long inputs, a short instruction placed after the document usually holds up better than one buried at the top.
- Send whole documents instead of chunks where you can. The value of this window is avoiding a retrieval pipeline you no longer need.
- Watch your own request size. A very large prompt means a long round trip before the first token — the latency figure is P50 for a reason.
- Verify the window yourself if you depend on the far end of it. The 1M ceiling has been confirmed by binary search independently, but your retrieval quality at 900K tokens is a separate question worth testing with a needle-in-a-haystack check.
Reliability: plan for the gap
The OpenRouter listing observed on 25 September 2026 reports 99.76% uptime over three days, 98.24% availability over three days and 98.57% OpenRouter availability over the last 24 hours. These are metrics for the OpenRouter gateway snapshot, not TokenRA's route and not an independent measurement of the anonymous upstream provider. OpenRouter says it can route to another healthy provider when an error occurs; that fallback behavior must not be assumed for TokenRA. Keep a fallback in your application and treat these values as a changing snapshot.
- Retry with a fallback model. Keep a second model ID in config and retry on error or empty response. This is also the mechanism that saves you when the free preview ends.
- Log failures explicitly. Distinguish a transport error from an empty completion — they point at different problems, and only one of them is your prompt.
These uptime and availability figures are live values displayed by the OpenRouter gateway listing; this snapshot was observed on 25 September 2026. They do not describe TokenRA routing or establish the upstream provider's reliability. We track the snapshot over time on our benchmarks page.
What it is good at, based on actual usage
The most useful deployment signal available is the list of public apps sending the most traffic to this model — and every one of the top five is a coding agent:
| App | Tokens | Workload |
|---|---|---|
| Cline | 54.1B | IDE coding agent |
| Claude Code | 50.4B | Agentic coding |
| Hermes Agent | 32.1B | Autonomous agent with tool use |
| DeepSeek Harness | 30B | Agent harness |
| Kilo Code | 28.9B | Agentic coding |
Read that as a recommendation from people who have already run it at volume: long-context agentic coding is the workload this model is being used for, which fits the 1M window and tool-calling support. It is not evidence of quality on other tasks — no benchmark scores exist for this model at all, which is covered in detail on our benchmarks page.
Checklist before you ship
- Model ID stored in a single config value
- Fallback model configured and tested
max_tokensexplicitly capped- JSON responses validated before use
- API key in environment variables, never in source
- A retry path that survives the free preview ending
Space Bunny Alpha API FAQ
How do I use the Space Bunny Alpha API?
Get a TokenRA API key, point an OpenAI-compatible client at https://tokenra.io/v1, and set the model ID to space-bunny-alpha. No separate signup or payment method is needed while the free preview lasts.
Is it really free?
Yes, at the time of writing — the listing shows zero price for prompt and completion tokens during the stealth preview. The pattern in this model series is that the free window ends when the provider claims the model, so avoid a hard dependency without a fallback configured.
Does it support tool calling and JSON output?
Yes to both. It accepts tools and tool_choice for function calling, and supports response_format for JSON output — but without JSON-schema enforcement, so validate the returned JSON yourself.
What is the maximum output length?
The context window is 1,000,000 tokens and the maximum completion length is 524,288 tokens. Set max_tokens deliberately for your use case rather than relying on the ceiling.