The reason you are agonising over this decision is wrong. Teams treat the embedding model as a one-way door because re-embedding the corpus sounds ruinous. It is not. At 10 million chunks averaging 400 tokens each, the token bill to re-embed the entire corpus is $520 with OpenAI's text-embedding-3-large at $0.13 per 1M tokens and $480 with voyage-4-large at $0.12 per 1M tokens. That is less than a single engineer-day. The lock-in is real, but it lives somewhere else, and this page is about finding it.
The verdict: default to voyage-4-large. It publishes a rate card, its 1024 default dimensions sit well inside the ceiling pgvector can index with HNSW without a type change, and its family shares one embedding space so you can swap models inside it without touching the index. Self-host Qwen3-Embedding if data residency or a fixed monthly bill is the binding constraint. Pick Cohere Embed 4 when your chunks genuinely exceed 32k tokens or carry images. Do not start on OpenAI in 2026 — text-embedding-3-large shipped in January 2024 and, per OpenAI's own pricing page today, still has no successor.
The workload everything below is normalised to: 10M chunks × ~400 tokens (4B tokens to index), ~4M queries a month at 40 tokens each, one HNSW index, list prices checked 2026-09-20.
| Model | Price / 1M tokens | Dims (default / options) | Max context | Quantized output | Residency | Verdict |
|---|---|---|---|---|---|---|
| voyage-4-large | $0.12 | 1024 / 256, 512, 2048 | 32k | int8, uint8, binary | API only | Default pick |
| voyage-4-lite | $0.02 | 1024 / 256, 512, 2048 | 32k | int8, uint8, binary | API only | Query-side companion |
| Cohere Embed 4 | Not published | 1536 / 256, 512, 1024 | 128k | int8, uint8, binary | Dedicated instance | Long docs and images |
| Qwen3-Embedding-8B | Self-hosted | 4096 / any 32–4096 | 32k | Yours to choose | Apache-2.0, anywhere | Residency and sovereignty |
| Qwen3-Embedding-0.6B | Self-hosted | 1024 / any 32–1024 | 32k | Yours to choose | Apache-2.0, anywhere | The cheap self-host |
| OpenAI text-embedding-3-large | $0.13 | 3072 / shortenable | 8k | None | API only | The loser |
Re-embedding 10M chunks costs $520, so stop calling it lock-in
The embedding API bill is not the switching cost. Four billion tokens at OpenAI's $0.13 per 1M is $520; at voyage-4's $0.06 it is $240, and voyage-4-lite at $0.02 brings it to $80 — with the first 200M tokens free on all three. Your ongoing query volume is rounding error next to that: 4M queries at 40 tokens is 160M tokens, about $20 a month.
The switching cost is three other things, and none of them appear on an invoice.
One: every threshold you tuned is calibrated to one model's score distribution. The similarity > 0.78 filter in your retrieval code, the reranker cutoff, the "no confident answer" guard — all of it was fitted to the geometry of the old vector space and none of it transfers. That is a re-baselining exercise against a labelled eval set, which is why pooling relevance judgments so they can be reused across candidates is the highest-leverage thing you can do before you ever pick a model.
Two: a dimension change is a schema migration, not a value update. Going from 1024 to 3072 dimensions means a new column, a new index, and both indexes resident simultaneously during cutover. On Pinecone at $0.33/GB/month that is a temporary doubling; on self-hosted Postgres it can be an instance-class change.
Three: you cannot dual-write your way out if the model family does not let you. This is the one genuine differentiator in the comparison. Voyage's January 2026 release notes state that across the voyage-4 family "all four models produce compatible embeddings, meaning embeddings generated from different models can be used interchangeably" — query embeddings from voyage-4-lite can search documents embedded with voyage-4-large. Embed the corpus once with the expensive model, serve queries with the cheap one, and change your mind later without re-indexing. Nobody else in this table offers that.
MTEB rank does not predict your corpus, and the gap is measurable
An embedding model's leaderboard position is a prior, not a decision. Chroma's generative-benchmarking work found a direct ranking reversal on production data: jina-embeddings-v3 outperformed text-embedding-3-large across all MTEB English tasks yet delivered lower retrieval performance than it on real WandBot queries, where text-embedding-3-large reached Recall@10 of 0.552. Their conclusion is worth quoting to anyone on your team still shopping by leaderboard: "strong performance on a public benchmark for a given embedding model does not guarantee comparable performance for your specific production pipeline."
It is not an isolated result. DisastIR evaluated 30 state-of-the-art retrieval models and found significant performance gaps between general-domain and disaster-management tasks, concluding that domain-specific benchmarks are necessary for model selection.
So treat every vendor comparison — including the ones below — as a shortlist generator. Voyage claims voyage-4-large beats OpenAI v3 large by an average of 14.05% and Cohere Embed v4 by 8.20% across 29 RTEB datasets. That is the vendor's own run, and it covers all 29 datasets of a benchmark hosted by the MTEB project rather than a subset Voyage chose — but it is not an independently verified leaderboard placement, and MTEB maintainers have an open question about how voyage models were scored against RTEB's private datasets before those models were public. It tells you voyage-4-large belongs on the shortlist. It does not tell you it wins on your contracts, your tickets, or your claims files. Three hundred labelled query-document pairs from your own corpus will settle that in an afternoon and will outrank every number on this page.
Dimensions are an indexing problem, not a billing one
The dimension decision is worth about $27 a month and one hard compatibility wall. Here is the storage math at 10M vectors, float32, using Pinecone's published $0.33/GB/month as the yardstick:
| Dimensions | Bytes per vector | Vector payload | Storage / month |
|---|---|---|---|
| 3072 (OpenAI 3-large) | 12,288 | 122.9 GB | $40.55 |
| 1536 (Cohere Embed 4) | 6,144 | 61.4 GB | $20.28 |
| 1024 (voyage-4, Qwen3-0.6B) | 4,096 | 41.0 GB | $13.52 |
| 1024 as int8 | 1,024 | 10.2 GB | $3.38 |
| 1024 as binary | 128 | 1.3 GB | $0.42 |
Those are vector-payload floors — metadata and index overhead are extra. And the spread between the widest and narrowest float option is $27 a month, which is not a decision anybody should spend a meeting on.
The wall is elsewhere. pgvector's HNSW index supports the vector type up to 2,000 dimensions and halfvec up to 4,000, with each vector costing 4 * dimensions + 8 bytes. OpenAI's 3072-dimension default therefore cannot be HNSW-indexed as a plain vector in Postgres at all. You must either switch the column to halfvec or shorten the embedding — OpenAI's API does support a dimensions parameter, and the docs note a 3-large embedding "can be shortened to a size of 256 while still outperforming an unshortened text-embedding-ada-002 embedding with a size of 1536." Both are fine engineering. Both are a decision you did not know you were making when you picked the model, and if you are following the house position that you should stay on Postgres until something forces you off, it is the decision that bites first.
Where dimensions genuinely cost money is RAM. An HNSW index wants to be resident; 41 GB of 1024-dimension vectors fits comfortably on a 64 GB box, and 123 GB of 3072-dimension vectors does not. That is an instance class, not a storage line item.
Cohere stopped publishing a token rate for Embed 4
As of 2026-09-20, Cohere's pricing page lists no per-token rate for Embed 4. What it lists is dedicated capacity in its Model Vault: "Embed 4 Small: $4.00/hour or $2,500/month" and Embed 4 Medium at $5.00/hour or $3,250/month. The AWS Bedrock pricing page checked the same day still lists Embed 3 English and Embed 3 Multilingual at $0.0001 per 1,000 tokens — $0.10 per 1M — and does not list Embed 4.
Take that at face value rather than interpolating: if you want a token rate for Embed 4, you are asking a salesperson. This is the same pattern this site found across vector database pricing, where only pgvector publishes a rate anyone can check, and it has a concrete procurement consequence. A $2,500/month floor is $30,000 a year before you embed a single document, which makes Embed 4 a decision your finance team signs, not one an engineer makes on a Tuesday.
What you get for it is real. Embed 4, announced 15 April 2025, takes a 128k-token context — the docs list embed-v4.0 at 128k with output dimensions of "one of '[256, 512, 1024, 1536 (default)]'" and multilingual coverage of over 100 languages — and it handles images. If your retrieval corpus is scanned contracts, engineering drawings, or slide decks, that is not a nice-to-have, and the rest of this table cannot do it. Price it against Google's gemini-embedding-2 before you sign, though: it maps text, images, video, audio and PDFs into one space at a published $0.20 per 1M text tokens and $0.45 per 1M image tokens, with no instance floor. It was still in public preview as of September 2026, which is its own argument against building a production index on it — but it means Cohere's $30,000-a-year floor is not the only way to embed an image corpus. Cohere's enterprise model line has always been priced and sold to buyers who want a contract rather than a credit card.
A 128k context window does not mean you should use 128k chunks
Long context on an embedding model is a ceiling, not a recommendation. The LongEmbed work framed the problem precisely: while LLM context has been pushed past a million tokens, embedding models have been "confined to a narrow context window not exceeding 8k tokens," and extending them is its own research problem. A single vector has a fixed information budget. Push 100,000 tokens of a master services agreement into one 1536-dimension embedding and you get an average of the whole document, which matches nothing specific and retrieves for every query.
That is the practical asymmetry between the options. OpenAI's 8,192-token limit is documented for both 3-small and 3-large and is not a constraint if you chunk at 400–800 tokens, which you should. Cohere's 128k and Voyage's 32k matter for a narrower case: documents that resist chunking because the meaning is distributed — a table whose header is 40 pages from the row, a contract where the definitions section governs every clause.
Multilingual is where the gap is not a nuance. Qwen3-Embedding-8B and Cohere's multilingual line both claim over 100 languages, and Qwen3-Embedding-8B reports a 70.58 score and the No.1 position on the MTEB multilingual leaderboard as of 5 June 2025. OpenAI's models are multilingual but were tuned for it in January 2024. If your corpus is German contracts or Japanese support tickets, run the eval in that language or do not run it at all.
Self-host Qwen3 for residency, not for the bill
Self-hosting an embedding model is a data-residency decision that happens to be cheap, not a cost decision. Qwen3-Embedding-8B is Apache-2.0 with a 32k context and user-defined output dimensions from 32 up to 4096. Its small sibling is the one most teams should actually deploy: Qwen3-Embedding-0.6B is also Apache-2.0, tops out at 1024 dimensions — conveniently under pgvector's index ceiling — and scores 64.33 on the multilingual mean against the 8B's 70.58. Six points of benchmark for thirteen times the parameters is a trade most RAG systems should decline.
The serving path is boring, which is the point. Hugging Face's Text Embeddings Inference gives you dynamic batching, Flash Attention, Prometheus metrics and OpenTelemetry tracing in a container, with no graph-compilation step. Pull the weights from Hugging Face or run them on a managed GPU host like Baseten if you do not want the Kubernetes work.
Now the honest arithmetic. Modal lists an NVIDIA L4 at $0.000222/sec — $0.80 an hour, about $583 a month if you leave it running continuously. Your API alternative for the same workload was a $480 one-off index build plus roughly $20 a month in query embeddings. Self-hosting loses on price by an order of magnitude at this scale, and it keeps losing until either your query volume is genuinely enormous or your batch re-embedding is continuous rather than occasional.
So do it for the reason that actually holds: the text never leaves your VPC. That is the identical conclusion this site reached on the storage layer, where you should self-host the vector database for residency and not for the bill, and it is the deciding factor for the same buyers — EU data residency, a sovereignty clause, a regulator who wants to know which jurisdiction the inference ran in. If that is your constraint, Qwen3-Embedding-0.6B on an L4 clears it and nothing in the API column does, at any price. The broader version of that filter is in the sovereignty screen on OpenAI alternatives.
Who should not pick each of these
This is the part a vendor page will never give you.
- Do not pick voyage-4-large if you need a second supplier for the same vectors. One vendor, no open-weight fallback, and since MongoDB acquired Voyage AI in February 2025, your embedding roadmap now sits inside a database company's strategy. The models remain available through voyage.ai and the AWS and Azure marketplaces per that release, but if you are not a MongoDB Atlas customer, understand whose roadmap you are on.
- Do not pick Cohere Embed 4 if you cannot get a per-token rate through procurement, or if your chunks are 500 tokens. You would be paying a $2,500/month instance floor for a 128k context window you are not using.
- Do not pick Qwen3-Embedding if you have no GPU capacity, no one to own the container, and no residency requirement forcing your hand. A self-hosted embedder is a production service with a pager attached. The correct answer for most teams is an API.
- Do not pick OpenAI text-embedding-3-large because it is already in your contract. That is the only argument for it left, and it is the argument that quietly costs you a
halfvecmigration, an 8k context ceiling, no quantized output types, and a model with no successor in 32 months.
Name the loser plainly: it is OpenAI. Not because the model is bad — 3-large was excellent in 2024 and is still serviceable. Because every competitor here has shipped a new generation since, voyage-4 in January 2026 and Embed 4 in April 2025, while OpenAI's pricing page lists the same three embedding models it listed two years ago. For a component you re-index against for years, a supplier that has stopped iterating on it is the specific risk you are trying to avoid.
The decision, in the order that predicts regret
The criteria that actually determine whether you regret this, ranked:
This week. Build the eval set before you shortlist. Three hundred query-document pairs from your real corpus, labelled by someone who knows the domain. Every argument above is subordinate to what this measures.
This week. Check your index's dimension ceiling before you check anyone's benchmark. If you are on pgvector, 2,000 dimensions for vector and 4,000 for halfvec eliminates one option outright and forces a type change for another. On Pinecone or Qdrant the constraint is cost and RAM instead.
This month. Run the two cheapest credible candidates — voyage-4-lite and Qwen3-Embedding-0.6B — before the expensive ones. Both are 1024 dimensions, so if a cheap model clears your bar you have saved the dimension fight as well as the money.
This month. Price the quantization, not just the model. int8 output cuts the vector payload 4x and binary cuts it 32x; at 10M vectors that is $13.52 a month versus $0.42. Verify recall on your eval set, because that is a real accuracy trade, not a free win.
Before the contract. Get the per-token rate in writing or drop the vendor. An unpublished rate is a renewal negotiation you have pre-lost.
What changes the answer: images or tables in your retrieval corpus (Cohere), a hard residency clause (Qwen3), a sustained query volume above roughly 2,000 embedded tokens per second (self-host starts winning on price), or OpenAI finally shipping a fourth-generation embedding model (re-run everything).
The Bottom Line
The industry taught a generation of RAG teams to fear the embedding model choice, and the fear was misdirected. We treated a $520 line item as a one-way door while the actual door — the eval set that calibrates every threshold downstream, and the dimension count your index can physically accommodate — got picked by default. This is the same mistake the data warehouse era made about ETL: everyone negotiated hard on storage per terabyte and then discovered the switching cost was the 400 transformations nobody had documented.
Pick voyage-4-large, keep your embeddings at 1024 dimensions so Postgres can index them, label three hundred pairs from your own corpus, and re-run that eval every time a vendor ships. The model is the cheap part. The measurement is the asset.
Your embedding model is not a marriage. Your eval set is.
Continue Reading
Pinecone vs Weaviate vs pgvector: Stay on Postgres Vector Database Pricing: Only pgvector Publishes a Rate Self-Host the Vector DB for Residency. Not for the Bill. JPMorgan Ranked 62 Retrievers for $800. Pool the Judgments. What RAG Actually Costs: $1,308 a Month at 10M Tokens/Day RAG Build vs Buy: Buy the Index. Build the Eval Set. 7 OpenAI Alternatives. Only 3 Clear a Sovereignty Rule. Best RAG Platforms for Regulated Industries: Permissions First