NotCheap MAKE EVERY CREDIT COUNT
Analyze Your Costs

OpenAI Embeddings vs Cohere Embed vs Google Gemini Embeddings: Real Embedding Cost per 1 Billion Tokens in 2026

Share this guide

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.

For OpenAI, the model pages list text-embedding-3-small at $0.02 per million input tokens and text-embedding-3-large at $0.13. The Batch API supports embeddings at a 50% discount with a 24-hour completion window. Use that route for work that can wait, not for a visitor's live search query.

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 modelStandard rate per 1M tokensStandard, 1B tokensBatch, 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.0Confirm your rate, P1,000 × PConfirm 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.
OA
OpenAI
OpenAI text-embedding-3-small
text-embedding-3-small
$10
/ month (effective cost)
Base Fee:$0 / mo
Included Allowance:0 million tokens
Overages / Extra:$0.02 / extra unit
Free Access:No free API credits
Verified Rates ↗
CO
Cohere
Cohere Embed v3
Embed v3.0 (English & Multi)
$50
/ month (effective cost)
Base Fee:$0 / mo
Included Allowance:0 million tokens
Overages / Extra:$0.10 / extra unit
Free Access:1,000 free trial API calls/month
Verified Rates ↗

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:

ModelInitial import, batchMonthly documents, batchMonthly queries, standardOngoing 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.

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 dimensionsRaw bytes for 2M vectorsDecimal GB
7686,144,000,0006.144
1,0248,192,000,0008.192
1,53612,288,000,00012.288
3,07224,576,000,00024.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.

Your comparison period and cost estimates
Enter all four costs to see a comparison. Unknown is not zero.

Each total = initial/setup cost + months × recurring monthly cost. Costs are held constant throughout this projection; it does not forecast usage growth, inflation, hardware performance or future prices. Include contract commitments and rebuilds in your inputs, count each cost once, and use a consistent treatment of tax and labor. A shorter comparison period does not cancel an annual contract.

The fields start blank because we have no measured local running cost for your machine. The difference is arithmetic from your inputs, not a recommended model or a universal break-even point. This worksheet calculates in the browser; it does not run an embedding model or upload documents.

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.

PASS IT ON

Useful for your team?

Share this guide with a colleague.

LinkedInX
MoreShare

THE NOTCHEAPAI BRIEF

Want smarter AI choices without wasting money?

Smarter tools, honest pricing, useful alternatives and deals worth knowing.

Join The NotCheapAI Brief