Contents
Picking an embedding model feels like picking a phone plan. Everyone advertises the same features, the pricing pages hide the gotchas, and by the end you just want someone to tell you what to buy. Consider me that friend.
I've burned real money testing embedding APIs across production RAG systems, and here's the spoiler: the most expensive model is rarely the right one, and the cheapest one is sneakier than it looks. Let's break down the contenders — OpenAI, Voyage, Cohere, Google, and the open-weight crowd — with actual numbers from September 2026. Yes, I checked the prices. Someone had to.
IMO, once you've seen the price-per-million spread and the context windows side by side, this stops being a research project and becomes a five-minute decision — that's what the quick answer below is for. :)
Figure 1: Embedding API pricing and performance — the phone-plan comparison, minus the fine print
Image Alt Text: "Embedding model API pricing and performance comparison chart covering OpenAI, Voyage, Cohere, Google Gemini, and open-weight models"
The Quick Answer, Before the Details
If you're impatient (I respect it):
- Best bang for buck: Voyage 4 at $0.06 per million tokens
- Cheapest sane option: OpenAI text-embedding-3-small or Voyage 4 Lite, both $0.02 per million
- Best for long documents: Voyage 4's 32K context or Cohere embed-v4's massive 128K window
- Best for multimodal: Google's Gemini Embedding 2, which handles text, images, audio, and video in one vector space
- Best free-ish path: Voyage gives you 200 million tokens free per account, which covers a real prototype
FYI, embeddings only charge for input tokens — no output fees — which makes them 10 to 100 times cheaper than chat completions at the same volume. The real bill sneaks in through vector storage, where the platform choice decides your monthly floor, but we'll get there.
OpenAI: The Safe Default Showing Its Age
Everyone's first embedding call is OpenAI's, because the SDK sits in the same project as your chat completions. Text-embedding-3-small costs $0.02 per million tokens, making it the cheapest verified commercial API, and text-embedding-3-large runs $0.13. For the model-by-model history behind these two, our earlier OpenAI vs Cohere vs open-source comparison goes deeper.
The Good and the Gray Hairs
The small model hits MTEB retrieval around 62.3; the large reaches 64.6. Solid numbers — three years ago. Today, newer rivals beat both at similar or lower prices.
That said, OpenAI's Matryoshka support is genuinely useful. Truncate 3-large from 3,072 dimensions down to 1,024 and you keep roughly 95% of retrieval quality while cutting storage costs by about two-thirds — and smaller dimensions mean a lighter vector index too. Nice trick. Still the oldest models on the list, though.
Verdict: perfect for prototypes and budget pipelines. Just benchmark before trusting it with revenue-critical search.
Voyage: The Accuracy Nerd's Favorite
Voyage built its entire reputation on retrieval quality, and the benchmarks back it up. The Voyage 4 family spans three tiers: voyage-4-large at $0.12, voyage-4 at $0.06, and voyage-4-lite at $0.02 per million tokens, all with 32K context and dimensions from 256 to 2,048.
Why I Keep Coming Back
The mid-tier voyage-4 at $0.06 is the sweet spot in this entire comparison. In independent testing, voyage-3.5 posted a three-domain average nDCG@3 of 0.9429 — the best quality-per-dollar result among dense models tested.
Two more things I love:
- Shared embedding space across the 4 series: upgrade from lite to large later without re-embedding your entire corpus
- Domain variants: dedicated models for code, law, and finance, priced at $0.12
The free 200M tokens per account means your prototype costs exactly zero dollars. Try before you buy, the way everything should work. :)
Verdict: my default pick for production RAG where retrieval quality actually matters.
Cohere: The Enterprise Multilingual Workhorse
Cohere plays a different game. Embed-v4 ships with a 128K context window — the largest here — 1,536 dimensions, and strong multilingual support across 100+ languages.
The Secret Weapon: Binary Quantization
Here's the underrated feature nobody talks about at dinner parties. Cohere's native int8 and binary quantization shrinks each embedding dimension to a single bit, cutting vector storage by 32x compared to float32. At 100 million documents, that turns ~600 GB of vectors into roughly 75 GB. Your vector database bill just went on a serious diet.
One honest warning: Cohere's single-pass retrieval can wobble on query-versus-document phrasing mismatches. Pair it with Cohere Rerank — which Cohere designed for exactly this, and the same reranking stage any production RAG stack should have — and the combination outperforms either alone.
Verdict: best for messy enterprise documents, multilingual corpora, and storage-obsessed architects.
Google: The Multimodal Gambler
Gemini Embedding 2 handles text, images, audio, video, and PDFs in a single shared vector space — genuinely unique. If you're building cross-modal search ("find me the video that matches this paragraph"), it's the only serious option — and the multi-modal RAG crowd is where that use case lives.
The tradeoffs are real, though. At $0.20 per million tokens, it's the most expensive model here, and its 8,192-token context lags behind the 32K club. The free tier also lets Google train on your data, which rules it out for anything private.
Verdict: niche but unmatched — pick it for multimodal, skip it for text-only RAG.
The Open-Weight Rebellion
Self-hosting has quietly become excellent. Qwen3-Embedding-8B costs about $0.01 per million tokens via providers like OpenRouter and claims a 70.58 multilingual MTEB score. BGE-M3 on a spot A100 drops to roughly $0.001 per million — the cheapest option period once you're past ~15 million tokens a month.
The catch? You become the on-call engineer for a GPU. IMO, self-hosting wins below roughly $500/month in equivalent API spend — above that, the math favors owning the iron, and the infrastructure cost picture starts to look very different.
The Full Comparison
| Model | Price/1M tokens | Context | Standout trait |
|---|---|---|---|
| OpenAI 3-small | $0.02 ($0.01 batch) | 8K | Cheapest big-brand API |
| OpenAI 3-large | $0.13 | 8K | Matryoshka truncation |
| Voyage 4 Lite | $0.02 | 32K | Punches above its price |
| Voyage 4 | $0.06 | 32K | Best accuracy-per-dollar |
| Voyage 4 Large | $0.12 | 32K | Top API retrieval quality |
| Cohere embed-v4 | $0.12 | 128K | Binary quantization |
| Gemini Embedding 2 | $0.20 | 8K | Multimodal everything |
| Qwen3-8B (self-host) | ~$0.01 | 32K | Open weights, Apache 2.0 |
The Hidden Costs Nobody Mentions
Before you sign anything, remember three things:
- Storage beats generation. Embedding a billion tokens with OpenAI small costs a one-time $20. Storing those vectors in a managed database can run $200+/month, forever — cloud hosting is where that bill lives.
- Re-embedding is a migration. Switching providers later means re-embedding everything. At 100M documents, that's thousands of dollars plus engineering time — the incremental-ingestion pattern is what keeps the next switch from hurting this much.
- Benchmarks lie a little. MTEB scores are directional, not definitive. Always test on your actual documents — a top-leaderboard model can flop on your domain, which is exactly what honest RAG evaluation is for.
Common Mistakes Teams Make Choosing an Embedding Model
- Picking by leaderboard rank alone. Your corpus is not MTEB; a domain eval on 50-100 real queries beats any leaderboard position.
- Comparing price per million tokens while ignoring dimensions. A cheap model at 3,072 dimensions stores 12x more than the same model truncated to 256 — the index bill outlives the embedding bill.
- Treating free tiers as free. Gemini's free tier trains on your data; Voyage's free tokens don't. Read the retention terms before you upload anything private.
- Forgetting batch endpoints. 3-small halves to $0.01 with batching, and nightly re-embedding jobs don't need real-time latency anyway.
- Hardcoding the provider SDK into ingestion. Abstract the embedding call behind one function from day one, and swapping models stays a weekend project instead of a migration.
Recommended Books
- Natural Language Processing with Transformers by Tunstall, von Werra, and Wolf — how embedding models actually work under the hood, including the fine-tuning tricks behind the domain variants in this comparison.
- Machine Learning Engineering by Chip Huyen — production cost thinking, batching, and serving decisions that decide whether your embedding bill stays a rounding error.
- AI-Powered Search by Trey Grainger et al. — retrieval quality end to end, which is the actual job your chosen embedding model is being hired to do.
Unlock AI That Actually Works
Get lifetime access to GPT-6 Astra, Claude Fable 5.1, Gemini 3.5, Grok 4.5, and more — all in one platform. Build websites, apps, videos, content, and digital products from a single command. No monthly fees. No tool-hopping.
Click here to get GPTAstra Max now — one-time payment, lifetime access.
Frequently Asked Questions
What is the cheapest embedding API?
Among big-brand APIs, OpenAI text-embedding-3-small and Voyage 4 Lite both cost $0.02 per million tokens. Self-hosted open-weight models go lower still — Qwen3-Embedding-8B runs about $0.01 through providers like OpenRouter, and BGE-M3 on a spot A100 drops to roughly $0.001 per million tokens once you pass about 15 million tokens a month.
Which embedding model is the most accurate?
Voyage. The voyage-4 family is built around retrieval quality, and voyage-3.5 posted a three-domain average nDCG@3 of 0.9429 in independent testing — the best quality-per-dollar result among the dense models tested. voyage-4 at $0.06 per million tokens is the sweet spot of this comparison.
How much do embedding APIs actually cost?
From $0.02 to $0.20 per million tokens across the commercial options here, and embeddings only charge for input tokens — no output fees — which makes them 10 to 100 times cheaper than chat completions at the same volume. The real bill usually hides in vector storage, which can run $200+ per month forever.
What context window do embedding models support?
Between 8K and 128K tokens depending on the model. OpenAI's 3-small and 3-large and Google's Gemini Embedding 2 offer 8K; the Voyage 4 family offers 32K; Cohere embed-v4 has the largest window at 128K tokens, which matters for long documents and messy enterprise PDFs.
When should you self-host an embedding model?
Around the $500/month mark in equivalent API spend. Below that, managed APIs win on convenience and quality; above it, open-weight models like Qwen3-Embedding-8B or BGE-M3 on your own GPU usually cost less — provided you've hired someone who enjoys GPU dashboards and on-call rotations.
Do embedding dimensions and quantization matter?
A lot, because they drive storage and index size. OpenAI's Matryoshka support lets you truncate 3-large from 3,072 to 1,024 dimensions and keep roughly 95% of retrieval quality while cutting storage by about two-thirds. Cohere's native int8 and binary quantization shrink storage by up to 32x versus float32.
My Bottom Line
Here's the decision tree I'd give a friend: prototype on OpenAI small or Voyage 4 Lite (both $0.02, practically free at small scale). Move production RAG to Voyage 4 when accuracy starts paying rent. Grab Cohere when your data is huge, messy, and multilingual. Go open-weight when your monthly API bill crosses that $500 threshold and you've hired someone who enjoys GPU dashboards.
The beautiful part? Swapping embedding models is a weekend project if you abstract your retrieval layer from day one. Do that, and you'll never be trapped.
Now go embed something — it costs less than the coffee you're drinking while reading this. :)