Embedding Model Cost Calculator: Vendor Comparison 2026

Embedding model cost is the most miscounted line item in a production RAG budget. The per-1M-token headline price hides the two numbers that actually decide the bill — refresh cadence and embedding dimensionality — and the wrong vendor choice compounds month after month for as long as the corpus keeps changing. This calculator reframes the decision around the math that matters.

What's at stake: a 1M-chunk corpus at 500 tokens per chunk is 500M tokens of initial ingest, and a 5% monthly refresh rate adds another 25M tokens every month indefinitely. Pick the vendor that looked $20 cheaper on a one-off ingest and you can spend the difference back inside a quarter once the refresh cycle starts running. The decision is structural, not price-list.

This guide compares five frontier embedding providers — OpenAI, Cohere, Voyage, Mistral, and Jina — across per-token pricing, dimensionality tradeoffs, MTEB and BEIR quality scores, refresh-cycle math over a 12-month horizon, and break-even corpus sizes where each vendor wins. Five archetypes at the end. Numbers sourced from each vendor's public pricing pages and benchmark reports as of May 4, 2026.

Five providers ship frontier-tier general-purpose embedding models into the market today. They share the same job to be done — turn a chunk of text into a dense vector that supports semantic similarity search — but they price, dimension, and benchmark differently enough that the right pick depends on the corpus, not the headline.

Below is the snapshot. Each card lists the flagship model, its native dimension, its standout positioning, and the workload class where the vendor most often earns a place on a shortlist. Read this as the map before reading the math.

The five-vendor map is stable enough to plan against for the rest of 2026, but pricing pages change quarterly and benchmark leaderboards shift as new models ship. Treat the cards above as the directional positioning; treat the numbers in §02–§04 as valid-as-of-May-2026 and re-verify before committing to a multi-year roadmap.

Per-1M-token list prices are the easy number to grab off a pricing page; what they hide is the realtime / batch split. Most embedding API providers now offer a discounted batch tier for asynchronous ingest workloads — useful precisely because initial corpus ingest and large monthly refreshes can run as batch jobs. Live query embedding still runs at realtime rates.

The matrix below is the operating choice for each vendor — when to pick realtime, when to pick batch, what the practical pricing tier delivers, and the workload class it fits. Numbers are illustrative-tier comparisons; verify exact rates on each provider's current pricing page before contracting.

The most common deployment we see in 2026 splits the workload: a batch tier for initial ingest and monthly refresh, a realtime tier from the same vendor for query embedding. Splitting across vendors is technically possible but operationally painful — you'd need to re-embed the entire query stream every time the ingest vendor changes, since cross-vendor vectors are not comparable.

One quiet gotcha worth flagging: free-tier or low-volume promotional pricing rarely survives the move to production traffic. Always model the cost calculation against the volume-tier rate you'll actually pay, not the introductory rate the pricing page leads with. The numbers in §04 use production-tier rates throughout.

Embedding dimension is the second-most-miscounted variable in a production RAG budget. The default for many providers ships at 1024 or 1536 dimensions; OpenAI's flagship goes to 3072. The cost of storing and searching those vectors scales linearly with dimension count, and the cost of returning a vector to a client (network bandwidth, JSON payload size) scales linearly too.

What changed in 2024–2025 is the broad adoption of matryoshka representation learning — models trained so that the first kdimensions of the embedding remain useful on their own. A matryoshka-trained 3072-dim embedding can be truncated to 1536, 1024, 512, or 256 dimensions with quality decay that is much gentler than naive truncation of a non-matryoshka model. OpenAI's text-embedding-3 family is the canonical example.

The decision framework is straightforward in concept and harder in practice: measure recall on a held-out retrieval set at full dimension, then re-measure at 1536, 1024, 512, and 256. Pick the smallest dimension where recall@10 drops by less than a threshold you set — most teams settle on 1–2 percentage points of MTEB-equivalent loss as the acceptable margin.

For non-matryoshka models (some Cohere and Voyage variants), the tradeoff is sharper — truncating a non-matryoshka vector tends to degrade quality much faster, so the practical move is to pick the dimension at training time and accept that as the operating point. Check each vendor's docs for whether matryoshka-style truncation is supported before betting the architecture on it.

The refresh-cycle formula is the calculator that this whole article exists to put in front of the reader:

12_month_cost
  = initial_ingest_cost
  + (refresh_rate_per_month × delta_chunks × tokens_per_chunk × cost_per_million_tokens × 12)

# where:
#   initial_ingest_cost = total_chunks × tokens_per_chunk × cost_per_million_tokens
#   refresh_rate_per_month = fraction of corpus that changes monthly (typically 2–10%)
#   delta_chunks = total_chunks × refresh_rate_per_month
#   tokens_per_chunk = average chunk length (typically 300–800)

Worked example. A 1M-chunk corpus at 500 tokens per chunk is 500M tokens of initial ingest. At a 5% monthly refresh rate, the delta is 50K chunks per month, or 25M tokens of recurring ingest. Over 12 months that is 300M tokens of refresh on top of the 500M-token initial ingest — refresh becomes roughly 38% of year-1 token volume, and crosses 50% somewhere in year 2 for most realistic corpora.

The lesson is simple and chronically underweighted: refresh dominates total cost on any corpus that lives longer than a year. A vendor that looked $200 cheaper on initial ingest can cost $600 more over three years if the per-token rate for steady-state refresh is structurally higher. Compare on the full horizon, not the launch month.

Two operational levers cut refresh volume materially. First, checksum-gated re-embedding: hash each chunk on ingest, compare against the stored hash on refresh, and only re-embed when the content actually changed. On a typical mixed content corpus (some documents drift, most don't), this often cuts refresh volume by 60–80% versus naive re-embed-all. Second, scheduled batching: queue refresh deltas across a week and submit them as a single batch job at the discounted rate, rather than firing realtime embedding calls on every content change.

Headline benchmark scores tell only the broadest version of the quality story. The two public leaderboards worth tracking are MTEB (Massive Text Embedding Benchmark) for breadth across 50+ retrieval, clustering, and classification tasks, and BEIR for depth on retrieval specifically. Both shift as new models ship; both still tell you which vendor leads at a given moment in time.

The chart below is an illustrative reading of where each frontier vendor sits on the MTEB English retrieval subset and the BEIR average as of May 2026. Numbers shift; the cluster-by-cluster shape is what matters for shortlist construction.

The cluster shape worth seeing: three vendors sit inside a narrow band at the top of the English-generalist benchmark (OpenAI, Voyage, Cohere), with Jina and Mistral a few points behind. Domain-specific variants from Voyage close or invert the gap on technical corpora — code, finance, law — where the domain model was actually trained to win.

Two practical takeaways. First, the top-of-leaderboard gap is narrowin 2026 — typically inside 5 points on MTEB English retrieval. If the per-token cost difference between vendors is 3–5× and the quality difference is <5 points, cost-led selection is defensible for most corpora. Second, the benchmark gap on your corpus may differ materially from the public leaderboard. Always run a small held-out retrieval eval on your own data before locking in a vendor for a multi-year roadmap.

With the cost formula in §04 and the quality cluster in §05, the break-even analysis falls out naturally. Each vendor wins on TCO somewhere on the corpus-size × refresh-rate plane; the structural break-evens are stable enough to plan against even as exact rates shift.

The matrix below maps corpus-size bands to the vendor that most often wins year-3 TCO at typical refresh rates, assuming production-tier pricing and ~5% monthly refresh on a mixed-content English-language corpus.

The break-evens above assume the refresh-cycle math from §04 is honest. If your corpus refreshes faster than the assumed 5% monthly — news, social, telemetry, anything with a fresh- content imperative — the break-even points shift earlier and cost-led selection becomes correct at smaller corpus sizes. If your corpus is static (regulatory text, technical standards, archived content) the break-evens shift later and quality-led selection holds longer.

One non-obvious wrinkle. The cost gap between vendors widens disproportionately when you include re-embedding for vendor migration. If you anticipate a need to swap embedding vendors inside the planning horizon — which is more common than teams admit — model the re-embedding cost explicitly and lean toward vendors with longer track records of pricing and model stability.

The matrices and the math collapse to five archetypes that cover most production RAG decisions in 2026. Pick the archetype that fits the corpus and the constraints, run a corpus-specific eval before contracting, and commit. Switch costs are real — minimise them by picking well the first time.

Two cross-cutting recommendations. First, measure recall before you spend: build a 50–100-query held-out eval set drawn from your actual product queries, score each candidate vendor against it, and only then move to the cost math. Cost-led selection on a vendor whose quality drops 8 points on your corpus is an expensive mistake. Second, plan the re-embedding budget into the year-2 line: vendor migrations happen, model upgrades happen, and dimension changes happen — re-embedding 500M tokens is a real bill that lives outside the steady-state refresh math.

If your team is shipping its first production RAG pipeline and the corpus is under 1M chunks, the OpenAI default plus batch ingest is the right starting point — almost every time. Our AI digital transformation engagements often start with exactly this kind of comparative eval, and our self-hosted RAG tutorial walks the production pipeline end-to-end with these vendor choices in mind.

For teams that have already shipped a RAG pipeline and suspect retrieval quality is the bottleneck rather than generation quality, the eight-point quality scorecard in our RAG system audit guide is the right next read — it covers the diagnostic side of the same decision.