Embedding API Cost 2026: OpenAI vs Cohere vs Jina AI
Embedding APIs power semantic search, RAG pipelines and recommendation engines. At scale, the wrong model can cost 7× more than the cheapest option. Here is the 2026 price breakdown.
How Embedding Pricing Works
All embedding APIs charge per token (input only — there is no output). Costs are quoted per million tokens. A typical document of 500 words ≈ 650 tokens. At 1M documents, that is 650M tokens.
2026 Embedding API Price Table
| Model | $/1M tokens | Dims | Max tokens |
|---|---|---|---|
| Jina AI v3 | $0.018 | 1024 | 8192 |
| OpenAI text-3-small | $0.020 | 1536 | 8191 |
| Cohere embed-v3 | $0.100 | 1024 | 512 |
| Voyage AI large-2 | $0.120 | 1536 | 16000 |
| OpenAI text-3-large | $0.130 | 3072 | 8191 |
| OpenAI ada-002 | $0.100 | 1536 | 8191 |
OpenAI text-embedding-3-small: Best Balance
At $0.020/1M tokens, text-3-small is 5× cheaper than ada-002 and competitive with Jina. It supports Matryoshka Representation Learning — you can truncate to 512 dims without significant quality loss, halving your vector DB storage.
Jina AI v3: Cheapest at Scale
Jina v3 at $0.018/1M tokens undercuts OpenAI by 10%. Supports task-aware encoding (query vs passage) and long documents (8192 tokens). Good for large-scale RAG pipelines where cost dominates.
Cost at Scale: 1B Tokens/Month
| Model | 100M tokens | 1B tokens | 10B tokens |
|---|---|---|---|
| Jina AI v3 | $1.80 | $18 | $180 |
| OpenAI text-3-small | $2.00 | $20 | $200 |
| Cohere embed-v3 | $10 | $100 | $1,000 |
| OpenAI text-3-large | $13 | $130 | $1,300 |
FAQ
How much does OpenAI embedding cost?
text-embedding-3-small costs $0.020 per 1M tokens. text-embedding-3-large costs $0.130/1M. Ada-002 (legacy) costs $0.100/1M. For most use cases, text-3-small offers the best cost/quality ratio.
Which embedding model is cheapest?
Jina AI v3 at $0.018/1M tokens is currently the cheapest quality embedding API. OpenAI text-3-small at $0.020/1M is close and benefits from OpenAI ecosystem integrations.
How do I reduce embedding costs?
Use text-3-small instead of text-3-large (6.5× cheaper). Cache embeddings — most documents don't change. Use batch embedding APIs where available. Truncate dimensions to 512 if quality holds.
APICalculators Team · Free developer cost tools. Prices from official documentation, reviewed monthly.
Embedding API Cost Optimization: A Practical Guide
Embedding costs look trivial per token but add up quickly in production RAG systems where every document chunk, every user query, and every re-indexing operation generates embedding calls. Here is how to keep embedding costs under control without sacrificing retrieval quality.
Batch everything. Embedding APIs charge the same per token whether you send 1 document or 1,000 in a single request, but batching dramatically reduces HTTP overhead and improves throughput. Most providers accept batches of 100-2,048 inputs per request. Always batch during initial indexing. Processing a 10,000-document corpus one-at-a-time versus in batches of 1,000 is the difference between 10,000 API calls and 10.
Cache embeddings aggressively. Once you have embedded a document chunk, store the embedding vector alongside the text in your vector database. Never re-embed the same content twice. Implement a content hash as a cache key so you only re-embed when the source document actually changes. For most knowledge bases, this means re-indexing costs are near-zero after the initial load.
Choose dimensionality wisely. OpenAI text-embedding-3-large (3,072 dimensions) costs 3x more than text-embedding-3-small (1,536 dimensions) per call and requires 2x more storage. For most retrieval tasks on English text, the small model performs within 2-5% of the large model on standard benchmarks. Unless you have measured a quality deficit on your specific domain, start with the smaller model.
Right-size your chunks. Larger chunks mean fewer embedding calls but worse retrieval precision. Smaller chunks improve precision but multiply your embedding and storage costs. For most enterprise documents, 256-512 token chunks with 10-20% overlap strike the best balance. Measure retrieval precision across chunk sizes using a small golden test set before committing to a chunk strategy at scale. Use the embedding API cost calculator to model your exact scenario.