Cohere vs OpenAI Embedding Cost (2026): embed-v4.0 vs text-embedding-3

Embedding cost for both OpenAI and Cohere follows the same simple formula — per-token input, no output bill:

``` embedding_cost = (total_input_tokens / 1_000_000) × price_per_1M Examples at 100M tokens: OpenAI text-embedding-3-small: 100 × $0.02 = $2.00 OpenAI text-embedding-3-large: 100 × $0.13 = $13.00 Cohere embed-v4.0: 100 × $0.12 = $12.00 Voyage voyage-3-large: 100 × $0.18 = $18.00 ```

Token count estimation: 1 token ≈ 4 characters of English. A 200-word document description is ~267 tokens. A 1M-row product catalog with 200-word descriptions is ~267M tokens.

The critical difference between OpenAI and Cohere that is invisible in this formula: **Cohere's context window is 128,000 tokens; OpenAI's is 8,192 tokens.** If any of your documents exceed 8,192 tokens (~6,000 words) and you need a single embedding for the full document, OpenAI cannot produce it without truncation. Cohere can embed the whole document. This is not a minor specification difference — it changes what you can build.

For the downstream costs after you have your embeddings, see how much RAG queries cost.

1M tokens is a small corpus — roughly 750,000 words, a modest note archive or a small product catalog.

**OpenAI text-embedding-3-small:** 1 × $0.02 = **$0.02** (two cents). Essentially free at this scale.

**OpenAI text-embedding-3-large:** 1 × $0.13 = **$0.13**.

**Cohere embed-v4.0:** 1 × $0.12 = **$0.12**.

**Voyage voyage-3-large (reference):** 1 × $0.18 = **$0.18**.

At 1M tokens, cost is not a decision factor. All four models cost under $0.20 for the full corpus embed. Pick on quality — run a 20-query held-out eval on your actual corpus, measure recall@10 and MRR, and pick the model that hits your bar. For English consumer text, text-embedding-3-small often matches or approaches the others at $0.02 vs $0.12-0.18. For multilingual text or long documents (4,000-8,000 word chunks), Cohere's advantages become visible at this eval stage.

100M tokens is a mid-market production system — a SaaS help center, a regulatory library, a years-deep support archive. At this scale, the cost gap between models is real but still small in absolute dollars.

**OpenAI text-embedding-3-small:** 100 × $0.02 = **$2.00**.

**OpenAI text-embedding-3-large:** 100 × $0.13 = **$13.00**.

**Cohere embed-v4.0:** 100 × $0.12 = **$12.00**.

**Voyage voyage-3-large:** 100 × $0.18 = **$18.00**.

OpenAI small saves $10 vs Cohere on the initial embed. If you re-embed once a year (model upgrade or chunking change), that is $20 saved annually. At this scale, cost is not the deciding factor — retrieval quality on your specific corpus and the context-window question are.

**Storage cost at 100M tokens:** A 100M-token corpus at 1,000-token chunks = 100,000 vectors. At 1,536 dims: 100,000 × 1,536 × 4 bytes = 614 MB raw. Negligible at any vector DB. At 10M chunks: 38.4 GB — now the dim count matters. Cohere embed-v4.0's configurable 256-dim minimum compresses dramatically: 10M × 256 × 4 = 10.2 GB vs 61.4 GB at 1,536 dims. Six times cheaper to store, at the cost of some recall precision.

A practical note: if your 100M-token corpus includes documents with 4,000-8,000 word long-form content (legal filings, academic papers, financial reports), Cohere's 128k context window lets you embed the whole document in a single pass rather than chunking. The chunking tax — duplicate context at chunk boundaries, loss of cross-paragraph co-occurrence — affects retrieval quality in ways that show up on hard queries.

1B tokens is enterprise-scale RAG — a global product catalog, a multi-jurisdiction legal archive, a full customer support dataset with years of ticket history.

**OpenAI text-embedding-3-small:** 1,000 × $0.02 = **$20.00**.

**OpenAI text-embedding-3-large:** 1,000 × $0.13 = **$130.00**.

**Cohere embed-v4.0:** 1,000 × $0.12 = **$120.00**.

**Voyage voyage-3-large:** 1,000 × $0.18 = **$180.00**.

Now the $100 gap between OpenAI small and Cohere/OpenAI large is real money. But at 1B tokens, the lifetime storage cost often exceeds the one-time embedding cost. Storage math at 1B tokens with 1,000-token chunks = 1M vectors:

``` Dim count impact on 1M-vector storage (Turbopuffer @ $0.10/GB-month): 256 dim: 1M × 256 × 4 bytes = 1.02 GB → $0.10/month 768 dim: 1M × 768 × 4 bytes = 3.07 GB → $0.31/month 1,536 dim: 1M × 1,536 × 4 bytes = 6.14 GB → $0.61/month 3,072 dim: 1M × 3,072 × 4 bytes = 12.3 GB → $1.23/month ```

Over 24 months of operation, the storage cost for a 1M-vector index at 3,072 dims = $29.52 vs $2.40 at 256 dims — a difference that compounds with each additional 1M vectors in your index. At 1B tokens split into 1,000-token chunks = 1M vectors, OpenAI text-embedding-3-large at 3,072 dims stores 12.3 GB/M-vectors = 12.3 TB for a 1B-chunk corpus. Cohere at 256 dims = 1.02 TB. The 12x storage difference at extreme scale means the model choice affects your monthly vector DB bill for the lifetime of the index.

Cohere's configurable low-dim output is a meaningful cost lever at this scale, provided your recall@10 holds up. Verify on your eval set — do not assume 256 dims is sufficient without measurement. For most dense retrieval tasks, 512-768 dims represent a reasonable quality/storage tradeoff.

OpenAI text-embedding-3 has an 8,192-token context limit. Documents longer than ~6,000 words must be chunked before embedding. Cohere embed-v4.0 supports 128,000 tokens — roughly equivalent to a 90,000-word document (a full-length book chapter or a detailed legal brief).

Why this matters for cost: chunking creates token overhead. When you split a 50,000-word document into 512-token chunks with a 50-token overlap, you generate roughly 200 chunks and embed approximately 102,400 tokens (51,200 base + 10,000 overlap) — 4% token waste from overlap alone. On a 100M-word corpus, that 4% overlap adds 4M tokens to your embedding bill.

More significantly, chunking overhead on Cohere vs OpenAI changes the token economics on long documents. If your use case includes full-document embedding (for global document-level retrieval before chunk-level reranking), Cohere can embed a 50,000-word document in a single API call. OpenAI requires splitting it into 7-8 chunks minimum, each embedded separately. The extra API calls are negligible in cost, but the retrieval quality difference — embedding context lost at chunk boundaries — can be material on long-document retrieval tasks.

Teams building RAG for: legal contract review, academic literature retrieval, medical records synthesis, or financial filing analysis should benchmark Cohere's full-document embedding against OpenAI's chunked approach on their actual queries. The quality difference on cross-paragraph questions (where the answer requires context from two different sections of a long document) tends to favor longer-context embeddings.

OpenAI text-embedding-3 defaults to 1,536 dims (small) and 3,072 dims (large), but supports a `dimensions` parameter for reduction. Cohere embed-v4.0 supports 256-1,536 configurable output dims. This is where the models converge — both can produce low-dim vectors that reduce storage cost at controlled quality cost.

``` Storage comparison at 1M vectors, 12 months, Turbopuffer @ $0.10/GB-month: OpenAI text-embedding-3-small (default 1,536 dim): 6.14 GB × 12 × $0.10 = $7.37/year per 1M vectors OpenAI text-embedding-3-large (default 3,072 dim): 12.3 GB × 12 × $0.10 = $14.75/year per 1M vectors OpenAI text-embedding-3-large (configured to 768 dim): 3.07 GB × 12 × $0.10 = $3.68/year per 1M vectors Cohere embed-v4.0 (1,536 dim, default): 6.14 GB × 12 × $0.10 = $7.37/year per 1M vectors Cohere embed-v4.0 (512 dim, reduced): 2.05 GB × 12 × $0.10 = $2.46/year per 1M vectors ```

The reduction ratios are comparable, but the starting points differ: OpenAI large starts at 3,072 dims and needs to be cut to 768 or less to match the storage efficiency of the others; Cohere starts at a flexible range. For storage-optimized deployments, Cohere at 512 dims is slightly cheaper to store than OpenAI small at its 1,536 default — though both are cheap in absolute terms at 1M vectors.

The recommendation: do not pick dimensionality based on defaults. Run your retrieval eval at 768 dims vs 1,536 dims vs 3,072 dims on your actual corpus. For most English consumer text, the recall@10 difference between 768 and 1,536 dims is under 2%. For technical, multilingual, or cross-domain corpora the gap widens — measure before deciding.

Cohere's embed-v4.0 is designed to pair with Cohere Rerank v3, which costs $1/1,000 queries on the production tier = $0.001/query. OpenAI does not offer a native reranker — teams using OpenAI embeddings typically pair with Cohere Rerank or an open-source cross-encoder (e.g., cross-encoder/ms-marco-MiniLM from HuggingFace, self-hosted).

Full pipeline cost comparison at 100K queries/month:

``` OpenAI text-embedding-3-small + Cohere Rerank: Corpus embed (100M tokens one-time): $2.00 Query embed (100K × 50 tokens = 5M tokens): $0.10/month Cohere Rerank: 100K × $0.001 = $100/month Total ongoing: $100.10/month Cohere embed-v4.0 + Cohere Rerank: Corpus embed (100M tokens one-time): $12.00 Query embed (5M tokens): 5 × $0.12 = $0.60/month Cohere Rerank: $100/month Total ongoing: $100.60/month ```

The full-pipeline cost difference at 100K queries/month is $0.50/month ($100.10 vs $100.60) — negligible. The corpus embed cost difference ($2 vs $12 one-time) is also small at 100M tokens. At this query volume, the reranker is the dominant retrieval cost in both pipelines — not the embedding model.

The practical implication: if you are using Cohere Rerank, the embedding model cost difference between OpenAI and Cohere becomes a minor factor in the total bill. Your decision should be driven by retrieval quality metrics and the 128k context window question, not by the $0.10 vs $0.12 per-1M-token price difference.

For a complete cost model including the LLM generation step after retrieval, see the RAG cost-per-query calculator.

**English-primary, consumer-grade corpus.** text-embedding-3-small at $0.02/1M tokens handles most English retrieval tasks without measurable quality loss versus premium models. SaaS help centers, product documentation, FAQ indexing, support ticket classification — if your corpus is primarily English and queries are keyword-extractable, start here.

**Budget-optimized systems.** At $0.02/1M vs $0.12/1M, text-embedding-3-small is 6x cheaper than Cohere for the same token count. On a 1B-token corpus, that is $20 vs $120 — a real difference if you re-embed quarterly.

**Short documents (under 1,000 words).** The 8,192-token context limit is not a constraint when individual documents are short. Product descriptions, support tickets, news articles, and emails typically fit well within OpenAI's context window. Chunking overhead is minimal or zero.

**OpenAI-ecosystem integration.** If your LLM stack already runs on OpenAI models, same-provider embeddings reduce the number of API keys, billing relationships, and SDK dependencies. Operational simplicity has real value in small teams.

**Matryoshka truncation.** OpenAI text-embedding-3 uses Matryoshka representation learning — the `dimensions` parameter lets you request a smaller vector that is a principled truncation of the full vector, not a lossy post-hoc reduction. This is architecturally cleaner than ad-hoc PCA reduction. Use it when storage cost matters more than maximum accuracy.

**Multilingual corpora.** Cohere embed-v4.0 is natively multilingual. If your corpus spans multiple languages — global product catalogs, international support content, multi-jurisdiction legal documents, cross-region academic literature — Cohere's multilingual architecture means you do not need separate embedding models per language or accept degraded retrieval quality on non-English text. This is the clearest differentiator.

**Long documents (above 4,000 words).** If your corpus includes long-form documents that benefit from full-document-level embeddings — financial filings, legal briefs, academic papers, medical records — Cohere's 128k context window enables single-pass embedding without the chunking tax. The quality benefit shows on cross-paragraph and long-range retrieval questions. OpenAI at 8,192 tokens requires chunking at ~6,000 words.

**Cohere reranker integration.** Cohere embed + Cohere Rerank is a tight same-provider integration with matching embedding spaces. If you are using Cohere Rerank for precision improvement, using Cohere embed for the initial retrieval is architecturally consistent. The marginal cost premium ($0.10 vs $0.02 per-1M on a query-embed basis) is negligible when the reranker dominates the retrieval bill.

**Enterprise context with Cohere platform commitment.** Cohere offers on-premises deployment, private cloud, and enterprise SLAs that OpenAI does not. For organizations with data residency requirements, regulated industries, or security review processes that prefer a single-vendor AI platform, Cohere's enterprise packaging may justify the price premium independent of per-token economics.

**Rule of thumb:** if two of the above four conditions apply to your use case, Cohere's 6x per-token premium is likely justified. If zero apply, text-embedding-3-small at $0.02/1M is the right default. Do not pay the Cohere premium for a monolingual English corpus of short documents — the retrieval quality difference will be minimal and the cost difference is measurable.

Beyond Cohere and OpenAI, the embedding model market in 2026 offers several alternatives. Here is the picker by use case:

**Cheapest English retrieval:** OpenAI text-embedding-3-small ($0.02/1M) or Voyage voyage-3.5-lite ($0.02/1M). Pick one, run your eval, pick whichever scores higher on your test set.

**Best price-per-quality mid-tier:** Cohere embed-v4.0 ($0.12/1M) if multilingual or long-document. Voyage voyage-3 ($0.06/1M) if English-primary and quality matters more than minimal cost.

**Premium English accuracy:** OpenAI text-embedding-3-large ($0.13/1M) or Voyage voyage-3-large ($0.18/1M). Use when retrieval quality is mission-critical on technical or high-stakes corpora. The $0.13 vs $0.18 gap is real at 1B tokens ($130 vs $180 one-time) — if both models pass your eval, text-embedding-3-large saves 28%.

**Multilingual:** Cohere embed-v4.0 ($0.12/1M) is the clear choice. Google gemini-embedding-2 ($0.20/1M) is a strong alternative with native Vertex AI integration. Both outperform OpenAI on cross-lingual retrieval benchmarks — verify specific language pair performance on your corpus before committing.

The model picker should always start with a held-out eval on your actual corpus and query distribution. Generic benchmarks (MTEB, BEIR) are useful signal but are not predictive for domain-specific or multilingual workloads. Spend 30 minutes building a 30-query eval set before committing to a model at production scale. See the full embeddings cost comparison for the complete pricing table across all providers.

Switching from OpenAI to Cohere (or vice versa) requires re-embedding your entire corpus. Vectors from different models live in different embedding spaces and cannot be mixed in the same index. The migration cost is: (re-embed the full corpus at the new model's per-token rate) + (rebuild the vector index) + (validate retrieval quality on a held-out test set before switching traffic).

``` Migration cost examples (1B-token corpus): OpenAI small → Cohere embed-v4.0: re-embed cost = $120 OpenAI large → Cohere embed-v4.0: re-embed cost = $120 (same destination) Cohere → OpenAI small: re-embed cost = $20 Plus vector DB re-index write cost (Pinecone Serverless, 1M vectors): 1M × $0.33/1M write units = $0.33 (negligible) Total migration cost: dominated by re-embed, not re-index. ```

The decision threshold for switching: if the new model improves recall@10 by 3+ percentage points on your held-out eval AND your monthly query volume justifies the operational cost of a migration, switch. If the improvement is under 2 points, the migration cost + risk typically outweighs the quality benefit.

Staged migration pattern: (1) embed the new corpus in parallel alongside the old index; (2) A/B test 10% of live queries against the new index for 7 days, measuring answer quality; (3) switch 100% when metrics confirm parity or improvement; (4) deprecate the old index after 30 days of stable production. See the build-RAG-with-Pinecone tutorial for a worked example of a staged re-index migration.