The bottom line: for one billion billed text tokens, OpenAI text-embedding-3-small costs $20 on the standard API or $10 through Batch. Google's gemini-embedding-001 costs $150 standard or $75 batch. The catch is that those are embedding charges, not a complete search service.
When you pick an embedding model for search, two questions matter most: does it find the passages your users need, and what will it cost to keep that search working? A cheap first import is nice, but it says nothing about the cost of updates, queries or switching models later. Below, we work through the remaining choices without assuming a bigger vector is better, or that storage always dominates the bill.
Prices and documentation were checked on 31 October 2026. This is a source-based buying comparison with illustrative calculations, and we haven't benchmarked these models on your documents. USD figures exclude taxes and negotiated terms.
My practical rule of thumb: the price gap between these models is real, but it's usually small next to the cost of choosing a model that retrieves poorly and having to re-embed everything. Test quality first, then let price break the tie.
Choose the exact model and access route
An embedding turns an input into a list of numbers that a search system can compare. You still need somewhere to keep those vectors and a way to retrieve matching passages. A chat subscription doesn't establish the API rates in this guide, and a cloud marketplace or managed search product can bill differently from the direct APIs below.
Google's Gemini Developer API pricing lists both gemini-embedding-001 and gemini-embedding-2. The newer model now has published text rates, so it's no longer just a preview price. Its other input modalities are priced separately, so this comparison keeps the workload text-only. These are Developer API rates, not a Vertex AI quote.
For Cohere, keep embed-v4.0 separate from the newer Embed 5 family. The current pricing page presents Model Vault instance pricing, which can't stand in for a v4 per-token rate. We couldn't verify a current direct v4 token price, so the budget below uses a variable for your own rate. Check the model, deployment route, production access and billable unit in your account or quote. Trial access isn't a production allowance.
What one billion text tokens costs
Embedding charge = billed input tokens ÷ 1,000,000 × the applicable rate. Count the same sample with each provider's tokenizer before comparing a real corpus. One billion tokens is a billing scenario, not a promise of the same number of words, documents or vectors everywhere.
Direct API model
Standard rate per 1M tokens
Standard, 1B tokens
Batch, 1B tokens
OpenAI text-embedding-3-small
$0.02
$20
$10
OpenAI text-embedding-3-large
$0.13
$130
$65
Google gemini-embedding-001
$0.15
$150
$75
Google gemini-embedding-2, text input
$0.20
$200
$100
Cohere embed-v4.0
Confirm your rate, P
1,000 × P
Confirm separately
INTERACTIVE 2026 BENCHMARK · WORKLOAD SIMULATOR
Interactive OpenAI text-embedding-3 vs Cohere Embed v3 Cost Simulator
Simulate your exact volume, calculate live effective costs, and evaluate overage fees for OpenAI text-embedding-3 vs Cohere Embed v3.
⚡
Simulate Your Monthly Volume
Adjust slider or choose presets for million tokens / month:
million tokens / month
🏆OpenAI text-embedding-3-small is cheaper for this workload: save $40/mo ($480/year) compared to Cohere Embed v3.
P means dollars per million billed text tokens for the specified route. It's a variable, not a Cohere price. Also, a request containing several inputs doesn't, by itself, qualify for discounted asynchronous batch billing. Check model support, job limits and failed or incomplete inputs before scheduling a large import.
A budget you can adapt: first import, then monthly use
Suppose your initial import contains 1B billed tokens. After that, each month you embed 100M new or changed document tokens, plus 1M search queries averaging 20 billed tokens each. The query workload is therefore 20M tokens. These are planning assumptions, not measured traffic. To keep the comparison fair, we hold those counts equal across providers, so swap in your actual numbers before buying.
Assume the document work can use batch pricing while search queries use the standard API:
Model
Initial import, batch
Monthly documents, batch
Monthly queries, standard
Ongoing embedding total per month
text-embedding-3-small
$10
$1
$0.40
$1.40
text-embedding-3-large
$65
$6.50
$2.60
$9.10
gemini-embedding-001
$75
$7.50
$3
$10.50
gemini-embedding-2, text
$100
$10
$4
$14
These totals exclude the initial import in subsequent months. If document updates need immediate processing, use standard rates for that column too: the ongoing totals become $2.40, $15.60, $18 and $24 respectively. For Cohere, use 100 × your document rate + 20 × your query rate. If both use the same standard P, that's 120 × P.
A full rebuild adds another entire corpus charge. If only a small portion changed, check whether you can update just those chunks. Keep document identifiers and the model configuration alongside your index, so a future migration doesn't turn into a mystery about which vectors belong together. Future-you will be grateful.
Set up retrieval correctly before judging the model
Use compatible document and query embeddings with the same chosen output dimensions. Equal vector length alone doesn't make two different models compatible. A model migration normally needs a new index and re-embedding, so verify any explicitly documented compatibility rather than assuming it.
OpenAI: the embedding guide gives default sizes of 1,536 for small and 3,072 for large. Both support the dimensions parameter. Their per-input limit is 8,192 tokens. Choose a supported size, keep it consistent and test retrieval before reducing it further.
Cohere v4: the model specification supports 256, 512, 1,024 or 1,536 dimensions, with 1,536 the default. It isn't fixed at 1,024. The Embed API uses output_dimension. For search, encode stored passages with input_type="search_document" and queries with input_type="search_query". Those roles are deliberately different. The truncate setting also matters: reject or split oversized inputs on purpose rather than silently dropping text.
Gemini: Google's embedding instructions recommend 768, 1,536 or 3,072 dimensions through output_dimensionality. For 001 retrieval, pair RETRIEVAL_DOCUMENT with RETRIEVAL_QUERY. Normalize 001 vectors manually at reduced dimensions, as documented. Embedding 2 handles that normalization automatically. Follow the instructions for the exact model you use.
Break long documents into useful passages before costing the job. Overlapping chunks, repeated text and reprocessing can all increase billed input. A document containing ten chunks generally creates ten stored vectors, not one, so don't infer vector count from the number of source files.
Work out vector size without inventing a database bill
For a simple illustration, assume the 1B-token import becomes 2M chunks of 500 tokens, with no overlap, one vector per chunk and float32 values. The raw vector payload is:
vector count × dimensions × 4 bytes
Chosen dimensions
Raw bytes for 2M vectors
Decimal GB
768
6,144,000,000
6.144
1,024
8,192,000,000
8.192
1,536
12,288,000,000
12.288
3,072
24,576,000,000
24.576
Use only a size your chosen model supports. At this vector count, 3,072 dimensions use twice the raw payload of 1,536. That arithmetic doesn't mean twice the database bill, though. Metadata, the search index, replicas, backups, quantization, minimum capacity and query charges can all change the result. Raw GB is also not GiB or provisioned RAM.
To price a concrete configuration, see the vector database comparison. Put that estimate beside your embedding charge to see which part of your own workload deserves attention first.
Could you keep the embedding work on your own device?
If your documents must stay on a laptop, or search must work without a connection, a cheaper hosted API may not solve the problem. Local embedding is a different route: your own machine turns documents and questions into vectors. You take on the setup, updates and running costs instead of paying an embedding endpoint for that work.
One current option is Google's EmbeddingGemma 2. Its model card lists Apache 2.0 licensing, an 8,192-token context and 768-dimensional output, with supported smaller sizes. Text-only use can leave out the optional vision and audio encoders. These are documented capabilities, not a speed or retrieval-quality result from this site.
Google's local inference guide describes running on CPUs or consumer GPUs. Downloading the model is only the start. Follow its query/document instructions, output sizing and numerical-precision requirements, then test your actual documents. The model's memory footprint does not include your entire vector index, document parser or application. The raw-vector example above still needs storage even when the encoder runs locally.
Local embeddings also do not make every other stage local. A cloud vector store or a cloud model answering from retrieved passages can still receive your data. Prepare the required model files and software, decide where each stage runs, and verify the complete workflow without a network connection if offline use is essential. We have not downloaded or benchmarked this model here. Local-option documentation checked 1 November 2026; the API price check above keeps its own date.
Compare costs you can actually support
First establish that both routes meet your access and retrieval needs. Then enter your own estimates below. Include the first import and setup work once; put recurring updates, query processing, hardware or hosting, electricity, maintenance and any search/storage charges in the appropriate monthly budget. Use the same workload and accounting basis on both sides. Already-owned hardware need not mean a new purchase, but its use and upkeep still deserve a budget.
How to make the buying decision
Pick a representative set of documents and real questions, including awkward wording, missing answers and the languages your users need. Decide what counts as a useful retrieved passage before comparing results. Then measure retrieval quality, response time and cost with the same evaluation method. This guide doesn't supply a measured quality winner.
If the lower-cost model meets your target, that saving is yours to keep. If another model finds materially better evidence, weigh that benefit against its added cost and migration work. Smaller vectors deserve the same check, since fewer bytes alone don't prove an acceptable search result. Add reranking only when its measured benefit justifies another stage and another bill.
Before committing, put five numbers beside the retrieval result: initial import, monthly updates, query embeddings, a priced database configuration, and rebuild or migration cost. If you also need generated answers, budget those separately or compare the documented scope of a managed RAG service. That leaves you with a decision about a working search system, rather than a contest between token price labels.