402 PAYMENT_METHOD_REQUIRED with a zero balance, and the pricing page now lists per-token rates for all seven models with no free row at all. A payment method is required before any call succeeds. The free-tier figures below are kept for reference and are struck through; the pricing further down is current.Most free AI APIs make you choose between "big model, slow and paid" and "small model, fast and free." SambaNova collapses that trade-off: production-grade open models on custom silicon, fast enough that output streams as fast as you read, with a free tier, now withdrawn. Everything below comes from SambaNova's own rate-limits and pricing pages plus independent benchmarks — confirm the live numbers before architecting around them.
What is SambaNova Cloud?
A hosted inference API that runs models on SambaNova's own RDU (Reconfigurable Dataflow Unit) chips instead of Nvidia GPUs. The RDU keeps model weights close to compute, which is why it serves a 70B model at speeds GPU clouds usually reach only on much smaller models. For you it's an ordinary OpenAI-compatible API — base URL https://api.sambanova.ai/v1, standard Chat Completions shapes, the official openai library unchanged — serving Llama, DeepSeek, OpenAI's open-weight gpt-oss, and Gemma. It keeps a real Free tier with no payment method below a paid Developer tier — standing access, not a 14-day trial.
Is it free? The honest breakdown
No — not any more. There used to be a standing Free tier needing no card. Calling the API today returns 402 PAYMENT_METHOD_REQUIRED with a balance of 0, and the public pricing page lists per-token rates for every model with no free option. The historic free allowance is below for reference only:
| Former free tier (withdrawn) | Limit per model |
|---|---|
| Requests per minute | 20 |
| Requests per day | 20 |
| Tokens per day | 200,000 |
| Credit card required | Yes, now mandatory |
That allowance was already an evaluation budget rather than a production one, and it has now been withdrawn entirely. What remains genuinely useful without an account is the model catalog, which is served with no key at all — curl -s https://api.sambanova.ai/v1/models returns the current seven models and their context windows, so you can check the lineup before deciding whether to fund an account. One caveat if you use that as a health check: on an unfunded key /v1/models answers 200 with the full list while every /chat/completions call returns 402. We confirmed both on the same key minutes apart. A key that lists models is not a key that can run one. The models on offer:
| Model | Context | Max output | For |
|---|---|---|---|
| MiniMax-M3 | 1,048,576 | 1,048,576 | The long-context option — a million tokens, the largest here |
| gemma-4-31B-it | 262,144 | 262,144 | Multimodal — text, image, video input |
| MiniMax-M2.7 | 196,608 | 196,608 | Long context, previous MiniMax generation |
| gpt-oss-120b | 131,072 | 131,072 | OpenAI's open-weight model, tool use |
| Meta-Llama-3.3-70B-Instruct | 131,072 | 3,072 | General chat and agents — but see the output ceiling |
| DeepSeek-V3.1 | 131,072 | 7,168 | Strong reasoning and coding, MoE |
| DeepSeek-V3.2 | 32,768 | 7,168 | Newer DeepSeek generation, much shorter context |
Every figure above is what /v1/models returned on 3 September 2026,
not what the marketing pages say, and two of them are worth pausing on.
The flagship cannot write anything long.
Meta-Llama-3.3-70B-Instruct advertises a 131,072-token context and caps output at
3,072 tokens — roughly 2,000 words. It will happily read a long
document and cannot write one back. DeepSeek's two models sit at 7,168. If you
need long generation the choice is gpt-oss-120b, the MiniMax pair or
gemma, whose output ceilings match their context windows. No pricing page
mentions this; the model endpoint is the only place it appears.
MiniMax-M3 offers a million-token context, eight times the Llama flagship, and it is the reason to look at SambaNova for whole-codebase or whole-corpus work rather than for chat.
Getting a 70B model and a DeepSeek MoE served this fast is the pitch. It is no longer a free one, and Groq's free tier now covers the fast-and-free ground instead. The lineup shifts over time (an earlier campaign offered free Llama 3.1 405B), so check the live supported-models page.
The speed: why RDU matters
Per the neutral Artificial Analysis benchmark, SambaNova serves Llama 3.3 70B at ~400+ output tokens/second — among the fastest for that model, second only to Groq in some runs (SambaNova's own figures reach 580 t/s on Llama 3.1 70B, and over 1,000 t/s on an 8B model). In human terms that's far faster than you read, so streams feel instant — and it collapses agent-loop wall-clock time. An agent making ten sequential calls spends most of its life waiting on generation; a 400 t/s backend versus 40 t/s is a 10× cut in the latency you feel (SambaNova cites a typical GPU provider at ~20 t/s for these models). That big-model speed gap is the entire reason to reach for it.
Free vs paid: scaling up
When the 20-requests-per-day ceiling bites, link a payment method for the Developer tier — pay-as-you-go, capped at 20M tokens/day across all models:
| Model | Developer RPM | Developer RPD |
|---|---|---|
| Meta-Llama-3.3-70B-Instruct | 240 | 48,000 |
| DeepSeek-V3.1 / gpt-oss-120b / DeepSeek-V3.2 / gemma-4-31B-it | 60 | 12,000 |
| Model | Input / 1M | Output / 1M |
|---|---|---|
| Meta-Llama-3.3-70B-Instruct | $0.60 | $1.20 |
| gpt-oss-120b | $0.22 | $0.59 |
| gemma-4-31B-it | $0.22 | $0.59 |
| DeepSeek-R1-Distill-Llama-70B | $0.70 | $1.40 |
| DeepSeek-V3.1 | $3.00 | $4.50 |
gpt-oss-120b at $0.22 / $0.59 per million undercuts most hosted frontier models while running at RDU speed, and the catalog endpoint lets you check the lineup before attaching a card — the only thing that changes between tiers is your rate ceiling, not your code.
Get a key and make your first call
Sign up at cloud.sambanova.ai (a payment method is required before calls succeed), generate a key in API Keys, and export it. Point the OpenAI SDK at the base URL:
from openai import OpenAI
client = OpenAI(api_key="your-sambanova-api-key", base_url="https://api.sambanova.ai/v1")
resp = client.chat.completions.create(
model="Meta-Llama-3.3-70B-Instruct",
messages=[{"role": "user", "content": "Explain reconfigurable dataflow hardware in two sentences."}])
print(resp.choices[0].message.content)curl https://api.sambanova.ai/v1/chat/completions
-H "Authorization: Bearer $SAMBANOVA_API_KEY"
-H "Content-Type: application/json"
-d '{"model": "Meta-Llama-3.3-70B-Instruct", "messages": [{"role": "user", "content": "Say hello."}]}'Streaming, tool calling, JSON output, and system prompts all work with the standard parameters — point CrewAI, LangGraph, or any "OpenAI" provider at that base URL, or drop it behind LiteLLM (SambaNova is a first-class provider there) as one more model string.
SambaNova vs Groq vs Cerebras: the fast-free trio
| SambaNova | Groq | Cerebras | |
|---|---|---|---|
| Hardware | RDU (dataflow) | LPU | Wafer-scale (WSE) |
| Sweet spot | Large models fast (70B, DeepSeek, 120B) | Broad menu, high daily volume | Small models at extreme speed |
| Headline speed | Llama 70B ~400+ t/s | Very fast (LPU) | Fastest per-token (WSE), measured on the retired Llama lineup |
| Free tier shape | None — card required (free tier withdrawn 2026) | 30 RPM / 1,000 req/day (chat models), no card | None — $5 trial, 30-day expiry, card required first |
| OpenAI-compatible | Yes | Yes | Yes |
- Choose SambaNova when you need a large model (70B, DeepSeek MoE, gpt-oss-120b) running fast and you are willing to pay per token — big model, GPU-beating speed, card required.
- Choose Groq for generous daily request volume across a broad model menu (including Whisper) — the best default for high-frequency everyday calls.
- Choose Cerebras when raw speed is the whole game and a 30-day $5 trial (card required) is enough to evaluate it — it no longer has a permanent free tier.
For a benchmarked head-to-head including Google, see Groq vs Cerebras vs Gemini. Since all three speak OpenAI, the smart pattern is to register all of them behind a router and fall back between free tiers automatically.
SambaNova vs DeepSeek's own API
SambaNova serves DeepSeek models, but DeepSeek also runs its own API. Why go through SambaNova? Speed and unification: DeepSeek's first-party API is cheap but runs at conventional speeds, while SambaNova serves DeepSeek V3.1 on RDU hardware for dramatically higher throughput — plus Llama and gpt-oss behind the same key and OpenAI base URL. If latency matters and you want several models from one endpoint, SambaNova is the aggregation play; if you only need DeepSeek and cost is the sole concern, DeepSeek's own API is the direct route.
Limits and honest caveats
- There is no free tier any more — the former 20 requests/day allowance was withdrawn; a payment method is required before the first call succeeds (a config change, not a rewrite).
- The lineup shifts — check the live supported-models page rather than any article.
- Speed varies with load and context — 400+ t/s is best-case; benchmark your own workload.
- Free tiers move — confirm against the live rate-limits and pricing pages.
FAQ
Is the SambaNova Cloud API really free?
No. It was until recently — a standing free tier gave 20 requests/day and 200,000 tokens/day per model with no card. That is gone: the API now answers 402 PAYMENT_METHOD_REQUIRED on a zero balance and the pricing page shows per-token rates only. For a fast, genuinely free alternative see Groq, which still serves gpt-oss-120b at 1,000 requests/day with no payment method.
How fast is it compared to Groq and Cerebras?
They lead different categories. SambaNova serves large models fast — Llama 3.3 70B at ~400+ t/s per Artificial Analysis. Cerebras is fastest on small models (Llama 8B ~2,100 t/s). Groq offers broad coverage with high daily volume at 300-800 t/s. SambaNova's edge is speed on 70B-and-larger models.
What is an RDU?
Reconfigurable Dataflow Unit — SambaNova's custom AI chip, an alternative to GPUs whose dataflow architecture keeps weights close to compute, letting it serve large models at speeds GPU providers usually reach only on smaller ones. You never touch the hardware; you call a standard OpenAI-compatible API.
Does it work with the OpenAI SDK?
Yes. Point the openai library at https://api.sambanova.ai/v1 with your key and a model like Meta-Llama-3.3-70B-Instruct. Streaming, tool calling, and JSON output all work with standard parameters, so CrewAI, LangGraph, and LiteLLM treat it as a drop-in.
Bottom line
SambaNova Cloud is a fast paid inference API for people who need big models to move quickly. Where Groq and Cerebras earn their reputation on small-model speed and volume, SambaNova's RDU serves Llama 3.3 70B, DeepSeek V3.1, and gpt-oss-120b at 400+ t/s under a real no-card free tier. Evaluating a large model? gpt-oss-120b is the cheapest way in at $0.22 in / $0.59 out per 1M tokens. Building latency-sensitive UX or agent loops? ~400 t/s collapses the wait. Going to production? Link a card for 240 RPM and 20M tokens/day at cheap pay-as-you-go rates — no rewrite. It's not the pick for high daily request counts on the free tier, and its lineup shifts, so check the live docs — but as a paid, OpenAI-drop-in way to run production-grade models fast, it slots right next to Groq and Cerebras.
Related Reads
- Groq Free API Tested: ~525 tok/s + What You Can Build — the broad, high-volume fast free tier
- Cerebras API: Fast, But the Free Tier Now Needs a Card — extreme speed on smaller models
- Groq vs Cerebras vs Gemini: Free AI API Speed Test — the fast-inference field with public benchmarks
- DeepSeek API Is No Longer Free: We Checked the Balance — DeepSeek's own API, which SambaNova also serves
- Free AI APIs in 2026: We Tested 10, Four Now Want a Card — where SambaNova ranks against the whole field