Embedding Cost Calculator
Estimate the cost to embed a corpus for RAG or search — documents × tokens × model rate across OpenAI, Google, Voyage, Cohere & Mistral. Free, in-browser.
Embedding Cost Calculator
Storage for the vectors
| Stored as | Per vector | All vectors |
|---|---|---|
| float32 4 bytes per dimension | — | — |
| int8 1 byte per dimension | — | — |
| binary 1 bit per dimension | — | — |
Excludes the index (an HNSW graph, for example), ids, metadata and the chunk text. Units are decimal: 1 MB = 1,000,000 bytes.
Compare every model for this corpus
| Model | Per 1M | Corpus cost | Default dims | float32 storage |
|---|
How to Use the Embedding Cost Calculator
Pick an embedding model
Choose from OpenAI, Google, Voyage, Cohere or Mistral embedding models. Its per-million-token price, its input limit and the date the price was read appear under the dropdown.
Enter your corpus size
Put in how many chunks you'll embed and the average tokens in each. For RAG, the chunk is usually a few hundred tokens; if a chunk is longer than the model accepts, the tool says so.
Choose the vector size
Models that accept a smaller output dimension list the sizes they take. Smaller vectors cost the same to create but less to store; the storage table updates as you change it.
Compare before you commit
Open the comparison under the results to see every model priced for the same corpus, cheapest first. Re-embedding later costs the full amount again.
What It Costs to Embed a Corpus
Embeddings are cheap per token — but corpora are large
Embedding models turn text into vectors for semantic search and retrieval-augmented generation (RAG), and they are priced per input token like any other model, but far below chat models: on the models listed here, between $0.02 and $0.20 per million tokens when we read the vendors' pages on 3 November 2026. The catch is scale: a knowledge base, product catalogue or documentation site can run to hundreds of millions of tokens once chunked. At that size even a low per-token rate adds up, and the difference between a $0.02 and a $0.13 model is the difference between a few dollars and a few tens of dollars to index the same corpus. Knowing the number up front lets you choose a model deliberately rather than discover the bill after the import job runs.
The structure is simple: chunks × average tokens per chunk = tokens billed, and tokens × the model's rate = your cost. The variable people forget is chunking. RAG pipelines split documents into overlapping chunks, and overlap means the same text is embedded more than once, so your real token count is higher than the raw corpus. Each vendor also counts with its own tokenizer, so the same text gives a somewhat different total on each; a count measured with one vendor's tokenizer is an estimate for the others.
"Embedding is cheap per token and expensive per mistake. The costly part isn't the first run — it's re-embedding the whole corpus because you changed the model."
The cost you'll forget: re-embedding
The biggest hidden cost in a vector pipeline is that embeddings are, as a rule, model-specific. Vectors from different models live in different spaces and cannot be compared, so the day you switch embedding models you pay to re-embed the entire corpus from scratch. Two current families are the stated exceptions: Voyage AI says all embeddings from its voyage-4 series are compatible with each other, and Cohere says Embed 5 Pro and Fast share an embedding space, so a corpus indexed with one can be queried with the other. Changing your chunking means re-embedding whatever the model. Pair this with our Text Chunker to estimate realistic chunk counts, and the Token Counter to measure average chunk size.
What the vectors cost to keep
Creating vectors is a one-off bill; storing them is a running one, and it is set by the vector's size, not its price. A vector of d dimensions takes d × 4 bytes as float32, d bytes as int8 and d ÷ 8 bytes as binary, which is how Voyage AI's API reference defines those three types. Halving the dimensions halves the storage, which is why OpenAI, Google, Voyage and Cohere let you request a shorter vector than the default. OpenAI reports that text-embedding-3-large shortened to 256 dimensions still outscored the full-size text-embedding-ada-002 on the MTEB benchmark. The table in the tool covers the raw vectors only; the search index your vector database builds on top of them, and the chunk text you store beside them, come on top.
What the per-token price leaves out
The lowest rate listed here, $0.02 per 1M tokens, is shared by OpenAI's text-embedding-3-small and Voyage AI's voyage-4-lite.
Google lists a 2,048-token input limit for gemini-embedding-001 against 8,192 for gemini-embedding-2, and says longer inputs to the latter are silently truncated.
Batch pricing varies: Google lists its embedding batch rate at half the standard rate, Voyage AI's batch API is 33% off, and the OpenAI, Cohere and Mistral pages we read list no separate batch rate for embeddings.
Voyage AI gives every account its first 200 million tokens free on the voyage-4 models; its older models carry no free tokens.
A binary vector stores one bit per dimension, a thirty-second of the float32 size, at some cost in retrieval accuracy.
Only the input is charged: an embedding call returns a fixed-size vector, not generated text, so there are no output tokens to pay for.
Frequently Asked Questions
- Multiply the number of chunks by the average tokens in each to get the tokens billed, then multiply by the model's price per million tokens and divide by a million. Embeddings only charge for input, so there's no output cost to add.
- Count chunks. RAG pipelines split documents into smaller overlapping pieces before embedding, and each chunk becomes one vector, so the chunk count and average chunk size give both the token bill and the number of vectors you will store.
- Overlap repeats some text across adjacent chunks so context isn't lost at the boundaries. That repeated text is embedded, and billed, more than once, so a corpus with overlap costs more than its raw token count suggests.
- Dimensions × bytes per dimension × number of vectors: 4 bytes per dimension for float32, 1 for int8, and one bit for binary. The tool shows all three for the size you pick. That is the raw vectors only; your vector database adds its own index on top, and you will usually store the chunk text and metadata too.
- It depends on the vendor: some truncate the input and embed only the start, others return an error. Google says Gemini Embedding 2 truncates silently, and Voyage AI truncates by default unless you switch truncation off. Either way the end of the chunk is not represented, so the tool warns when your average chunk is over the selected model's listed limit.
- Vectors from different models generally live in different spaces and can't be compared, so switching models, or changing your chunking, means embedding the whole corpus again at the full price. Voyage AI's voyage-4 series and Cohere's Embed 5 Pro and Fast are documented exceptions within each family. Use the corpus cost here to size a migration in advance.
- Among the listed options, OpenAI's text-embedding-3-small and Voyage AI's voyage-4-lite share the lowest standard rate, and a batch rate can bring other models below it. Cheaper isn't always better: a model that retrieves better can be worth more, and storage at a large default dimension can outweigh a small difference in price. Open the comparison table to see both for your corpus.
- This tool sizes the one-time cost of embedding your corpus. At query time you also embed each incoming search query, but those are short (a few dozen tokens) and usually small next to the corpus. Add them in if your query volume is very high.
- Every price, batch rate, dimension and input limit was read from the vendor's own page on 3 November 2026, and that date is printed under the model dropdown. Embedding prices are kept apart from our chat-model rate card, so its date does not apply here. Providers retire and reprice embedding models, so confirm the live rate before budgeting a large indexing job.
Method & sources
How it computes
Cost = chunks × average tokens per chunk × USD per 1M input tokens ÷ 1,000,000, at the standard rate and, where the vendor publishes one, the batch rate. Storage = vectors × dimensions × bytes per dimension: 4 (float32), 1 (int8), 1/8 rounded up to whole bytes (binary); raw vectors only, no index (EmbeddingCostKernel).
What this tool implements
- Embedding APIs bill input tokens only; every vendor listed prices per million input tokens and returns a fixed-size vector, so there is no output charge.
- Batch is priced only where the vendor states it: Google lists gemini-embedding-001 at $0.075 and gemini-embedding-2 (text) at $0.10 per 1M on batch; Voyage AI states a 33% batch discount on its current models. OpenAI, Cohere and Mistral pages list no separate embedding batch rate, and the tool says "None published".
- Bytes per dimension follow Voyage AI's embeddings reference: float is 32-bit (4-byte), int8 is 1 byte, binary is bit-packed to a list 1/8 of the output dimension. Index structures, ids, metadata and the chunk text are excluded and the page says so; sizes use decimal units (1 MB = 1,000,000 bytes).
- Cross-checked against OpenAI's own "pages per dollar" table (about 800 tokens per page): 62,500 pages on text-embedding-3-small, 9,615 on text-embedding-3-large and 12,500 on text-embedding-ada-002 each come to $1.00.
- Corrected 2026-11-03: Cohere Embed v4 ($0.12) and v3 ($0.10) removed (no longer on cohere.com/pricing), replaced by Embed 5 Pro ($0.12) and Fast ($0.08); gemini-embedding-2 and voyage-4-large, voyage-4 and voyage-4-lite added; "vectors from one model can't be compared with vectors from another" qualified with the two documented shared-space families; the generic batch claim ("around half price") replaced by each vendor's stated rate.
Sources
- OpenAI. API pricing — Embedding (text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002), read 2026-11-03: https://developers.openai.com/api/docs/pricing
- OpenAI. Vector embeddings guide — default dimensions, the dimensions parameter, max input 8192, pages per dollar, read 2026-11-03: https://developers.openai.com/api/docs/guides/embeddings
- Google AI for Developers. Gemini Developer API pricing — Gemini Embedding and Gemini Embedding 2, standard and batch, read 2026-11-03: https://ai.google.dev/gemini-api/docs/pricing.md.txt
- Google AI for Developers. Embeddings — output_dimensionality, 3072 default, input limits, read 2026-11-03: https://ai.google.dev/gemini-api/docs/embeddings.md.txt
- Voyage AI. Pricing — text embeddings, older models, Batch API 33% discount, free tokens, read 2026-11-03: https://docs.voyageai.com/docs/pricing
- Voyage AI. Text embeddings — dimensions, context length, output_dtype widths, truncation, read 2026-11-03: https://docs.voyageai.com/docs/embeddings
- Cohere. Pricing — Embed 5 Fast and Embed 5 Pro per 1M tokens, read 2026-11-03: https://cohere.com/pricing
- Cohere. Cohere's Embed models — embed-v5.0-pro/fast dimensions, 128k context, shared embedding space, read 2026-11-03: https://docs.cohere.com/docs/cohere-embed
What can make this go out of date
- Model rows live in public/assets/vendor/reca-ai-data/llm-models.js `embeddings`, hand-maintained (instruments:sync-llm-data regenerates only the chat array and preserves this block), dated by `embeddingsAsOf`, which the page prints. Embedding prices are not in database/data/llm-rate-cards.php.
Abridged — the full review record for this tool runs longer than the list above.
Pick up where you left off
Stored only in this browser — never sent to our servers.