SambaNova Cloud: The Free Tier Is Gone (What It Costs Now)

On this page
  1. What is SambaNova Cloud?
  2. Is it free? The honest breakdown
  3. The speed: why RDU matters
  4. Free vs paid: scaling up
  5. Get a key and make your first call
  6. SambaNova vs Groq vs Cerebras: the fast-inference trio
  7. SambaNova vs DeepSeek's own API
  8. Limits and honest caveats
  9. FAQ
  10. Bottom line
⚠️ 2026 update: SambaNova's free tier did not work for us. In our own test on 2026-08-31 a free account got 402 PAYMENT_METHOD_REQUIRED with a zero balance, and the pricing page then listed per-token rates for all seven models with no free row. The rate-limits docs (checked 2026-10-09) still describe a free tier with no payment method, but our old key now returns 401, so we could not re-test. Plan on needing a payment method. The free-tier figures below are what the docs list, kept for reference.
Quick answer: SambaNova Cloud is a fast, OpenAI-compatible paid inference API that runs large models on its own RDU hardware — Llama 3.3 70B, DeepSeek V3.1, and gpt-oss-120b at ~400+ tokens/second, Its docs still list a free tier (20 requests/day and 200,000 tokens/day per model), but our free account was refused with 402 PAYMENT_METHOD_REQUIRED on 2026-08-31 — plan on a payment method before the first call. If you came here for a fast big-model API at $0, Groq is the replacement. Where Groq shines on volume (and Cerebras, now trial-only, on raw speed), SambaNova's niche is big-model speed, paid per token.

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 the docs still describe but our free account could not use. 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. Its docs still describe a Free tier with no payment method below a paid Developer tier, but our free account was refused without one (see below).

Is it free? The honest breakdown

Not in our test. The docs still describe a standing Free tier needing no card. But when we called the API on 2026-08-31 it returned 402 PAYMENT_METHOD_REQUIRED with a balance of 0, and the public pricing page listed per-token rates for every model with no free option. That old key now returns 401, so we have not re-tested since. The documented free allowance is below for reference only:

Free tier as documented (refused in our test)Limit per model
Requests per minute20
Requests per day20
Tokens per day200,000
Credit card requiredDocs: no. Our test: yes (402)

That allowance was an evaluation budget rather than a production one, and on our account it was not available at all. 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 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:

ModelContextMax outputFor
MiniMax-M31,048,5761,048,576The long-context option — a million tokens, the largest here
gemma-4-31B-it262,144262,144Multimodal — text, image, video input
MiniMax-M2.7196,608196,608Long context, previous MiniMax generation
gpt-oss-120b131,072131,072OpenAI's open-weight model, tool use
Meta-Llama-3.3-70B-Instruct131,0723,072General chat and agents — but see the output ceiling
DeepSeek-V3.1131,0727,168Strong reasoning and coding, MoE
DeepSeek-V3.232,7687,168Newer 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. (Re-read on 11 October 2026, the endpoint listed six models: MiniMax-M2.7 was gone, the other figures unchanged.)

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

A payment method moves you to the Developer tier — pay-as-you-go, capped at 20M tokens/day across all models:

ModelDeveloper RPMDeveloper RPD
Meta-Llama-3.3-70B-Instruct24048,000
DeepSeek-V3.1 / gpt-oss-120b / DeepSeek-V3.2 / gemma-4-31B-it6012,000
ModelInput / 1MOutput / 1M
Meta-Llama-3.3-70B-Instruct$0.60$1.20
gpt-oss-120b$0.22$0.59
gemma-4-31B-it$0.38$1.15
MiniMax-M3$0.60$2.40
DeepSeek-V3.1 / DeepSeek-V3.2$3.00$4.50

Prices as returned in the pricing field of /v1/models, checked 11 October 2026. An earlier version of this table listed DeepSeek-R1-Distill-Llama-70B, which the endpoint no longer serves, and gemma-4-31B-it at $0.22 / $0.59.

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. Once a card is linked, moving up tiers changes 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-inference trio

SambaNovaGroqCerebras
HardwareRDU (dataflow)LPUWafer-scale (WSE)
Sweet spotLarge models fast (70B, DeepSeek, 120B)Broad menu, high daily volumeSmall models at extreme speed
Headline speedLlama 70B ~400+ t/sVery fast (LPU)Fastest per-token (WSE), measured on the retired Llama lineup
Free tier shapeCard required in our test (402 on 2026-08-31; docs still list a free tier)30 RPM / 1,000 req/day (chat models), no cardNone — $5 trial, 30-day expiry, card required first
OpenAI-compatibleYesYesYes
  • 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 providers automatically — only Groq of the three still answers without a card.

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

  • The free tier did not work for us — the docs still list 20 requests/day, but our free account got 402 PAYMENT_METHOD_REQUIRED; plan on a payment method 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?

Not in our test. The docs still describe a standing free tier of 20 requests/day and 200,000 tokens/day per model with no card, but on 2026-08-31 the API answered our free account with 402 PAYMENT_METHOD_REQUIRED on a zero balance and the pricing page showed per-token rates only. Our old key now returns 401, so we could not re-check. 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, paid per token. 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 a free option in practice (our free account got 402), 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.