Embedding Cost Calculator

The embedding cost calculator estimates the full lifetime cost of turning your documents and search queries into vector embeddings for a retrieval-augmented generation (RAG) pipeline or semantic search system. Embedding APIs charge by the token, so the bill depends on how much text you push through the model rather than how many API calls you make. This tool turns raw inputs - document count, average document length, daily query volume, query length, the embedding model you pick, and how often you re-index - into concrete dollar figures for indexing, querying, re-indexing, and vector database storage.

Three cost buckets dominate any embedding budget. The first is initial indexing, a one-time expense to embed every document in your corpus. The second is query embedding, an ongoing cost because every user search must be embedded before it can be compared against the index. The third is re-indexing, which repeats the indexing cost on a schedule whenever your model or content changes. On top of those API charges sits vector storage, billed by your database provider based on how many floating-point dimensions each vector holds.

The calculator assumes a common tokenization heuristic of roughly four characters per token, which is accurate enough for English prose to produce reliable estimates. It also bakes in published per-million-token prices for popular providers, so you can compare OpenAI text-embedding-3-small, text-embedding-3-large, and ada-002 against Cohere and Voyage models side by side. Because embedding prices vary by more than 6x across these models, the difference between picking text-embedding-3-small at $0.02 per million tokens and text-embedding-3-large at $0.13 per million tokens can dominate your entire AI budget at scale. Use this embedding API pricing estimator before you commit to a vendor, so you can right-size your model choice and avoid surprises when your corpus grows from a thousand documents to a million.

The calculator follows the exact sequence your embedding bill would. First it converts characters to tokens using the four-characters-per-token rule, rounding up because providers never bill fractional tokens. Tokens per document equal the ceiling of average document length divided by four, and tokens per query follow the same formula. Multiplying tokens per document by your document count gives total document tokens, the figure that drives indexing cost.

Indexing cost is total document tokens divided by one million, multiplied by the model's price per million tokens. Query cost is computed daily - queries per day times tokens per query, divided by one million, times the price - and then scaled to monthly (times 30) and yearly (times 365) figures. Re-indexing cost takes the one-time indexing cost and multiplies it by a frequency factor: 0 for never, 1 for yearly, 4 for quarterly, 12 for monthly, and 52 for weekly. The total yearly cost sums indexing, yearly query cost, and yearly re-indexing cost.

Storage is estimated separately. Each embedding is stored as 32-bit floats, so bytes per document equal the model's dimension count times four. Total storage is documents times that per-document size, converted to gigabytes by dividing by 1024 cubed, then multiplied by an assumed managed vector database rate of about $70 per gigabyte per month. The model comparison panel re-runs the indexing and monthly query math for every supported model so you can see the price spread at a glance.

The cost of an embedding API is driven by two numbers: the price per million tokens and the vector dimension count. Price controls your indexing and query bills, while dimensions control your storage footprint and, indirectly, your similarity search latency. The table below shows the published rates and dimensions this calculator uses for each supported model.

The standout value is OpenAI text-embedding-3-small at just $0.02 per million tokens, which is five times cheaper than ada-002 while producing equally usable 1536-dimension vectors. The premium text-embedding-3-large doubles dimensions to 3072 and charges $0.13 per million tokens; it earns the higher retrieval accuracy on hard benchmarks but doubles your storage cost too. Cohere and Voyage models cluster around $0.10 to $0.12 with compact 1024-dimension vectors, which keeps storage lean and is attractive for multilingual corpora or specialized retrieval where their accuracy shines. When the embedding cost calculator shows two models with the same price, the one with fewer dimensions wins on storage, so a 1024-dimension model can be the better total-cost choice even at an identical per-token rate.

Embedding APIs are usually the small line item; the recurring vector database bill is what surprises teams as they scale. Each vector occupies its dimension count times four bytes in full fp32 precision. A 1536-dimension embedding is therefore 6,144 bytes, while a 3072-dimension embedding from text-embedding-3-large is 12,288 bytes - exactly double. Multiply by your document count and you have your raw index size before any database overhead, replicas, or metadata.

The calculator applies a managed-pricing assumption of roughly $70 per gigabyte per month, in line with pod-based vector database tiers. At a thousand 1536-dimension vectors the storage is trivial, but the relationship is linear in both document count and dimensions, so a corpus of ten million documents in 3072 dimensions consumes about 120 gigabytes and would cost thousands of dollars per month to host. This is why dimension reduction techniques matter. OpenAI's v3 models support shortening output dimensions, and quantizing vectors from fp32 to int8 cuts storage roughly fourfold with minimal recall loss.

Indexing cost is one-time, but re-indexing turns it into a recurring expense whenever you change models, update chunking, or refresh stale content. Choosing weekly re-indexing multiplies your indexing bill by 52 across a year, which can quietly dwarf both query and storage costs for a large static corpus. The smart pattern is to re-index only the documents that actually changed rather than the whole corpus, and to schedule full re-indexing only when you migrate to a new embedding model. Run the scenarios in this vector database cost estimator before locking in a re-index cadence so the schedule reflects how often your content genuinely changes.

The cheapest token is the one you never embed. Deduplicating near-identical documents, trimming boilerplate headers and footers, and excluding low-value pages from your index shrinks total document tokens directly, and indexing cost falls one-to-one with it. Smart chunking helps too: oversized chunks waste tokens on context the retriever never needs, while overly tiny chunks balloon the vector count and inflate storage.

On the query side, caching is the highest-leverage optimization. If a meaningful fraction of user searches repeat, caching the query embedding eliminates that token cost entirely. Because query cost scales with daily volume times 365, even a 30 percent cache hit rate trims a third off your yearly query bill. Batching multiple texts into a single API request reduces overhead and can improve throughput, though it does not change the per-token price.

Model selection remains the biggest lever. Defaulting to text-embedding-3-small at $0.02 per million tokens instead of ada-002 at $0.10 cuts both indexing and query costs by 80 percent for the same dimension count. If your retrieval quality holds, that is free money. Reserve text-embedding-3-large for the subset of high-stakes queries where its accuracy justifies the 6.5x price premium, or use it only at index time while embedding cheaper queries with a smaller model. Finally, watch storage: quantization and dimension truncation can deliver the steepest savings once your corpus grows past a few million vectors, because storage is billed every month forever while indexing is paid once. Combining a frugal model, query caching, incremental re-indexing, and quantized storage typically reduces total RAG cost by more than half versus a naive setup.