OpenAI Embeddings API Pricing in 2026, Dated and Checked
Nov 4, 202613 min read
According to embeddingcost.com, OpenAI charges $0.02 per million tokens for text-embedding-3-small and $0.13 for text-embedding-3-large, and Batch halves both. At those rates the list price is almost never what makes a bill large.
What an embedding is and how billing works
To search by meaning instead of by keyword, you turn a piece of text into a list of numbers, and that list is an embedding.
OpenAI sells this as a pay-as-you-go API with no seat fee or minimum, and it bills only for input tokens. A million tokens is roughly 750,000 English words.
A platform that resells you embeddings has picked the model and set the rate before you open it, which means it has made your AI decision for you.
Activepieces takes the opposite route: it runs the model you already chose on your own OpenAI key, so the small-or-large call stays yours and the tokens are billed to your OpenAI account at the rate on OpenAI's page.
On Plus and up, bring-your-own-key makes every AI step 1 credit, so the pricing page and your OpenAI invoice are the two numbers to compare against any reseller's markup.
MoneyGram, Moneypenny, Alan and FundingSocieties run it in production, and you can reach it from Claude, ChatGPT, Cursor or any MCP client. A shared API key still means one client's re-embedding job lands on everyone's invoice unless you track usage per client.
The price table, checked 2026-11-04
Read the price columns for what a corpus costs to embed, and the dimensions column for what it costs to store afterward.
| Model | Standard $/1M tokens | Batch $/1M tokens | Dimensions | Max input tokens |
|---|---|---|---|---|
| text-embedding-3-small | 0.02 | 0.01 | 1,536 | 8,192 |
| text-embedding-3-large | 0.13 | 0.065 | 3,072 | 8,191 |
| ada-002 | 0.10 | 0.05 | 1,536 | 8,191 |
Prices and plan limits checked against docs.claude.com and claude.com and openai.com and gemini.google on November 4, 2026.
Embedding a 50-million-token client archive costs $1.00 on small and $6.50 on large.
There's no price reason to start a new project on ada-002, the older model. It costs five times as much as small for the same vector size.
Large's 3,072 dimensions also mean every vector takes twice the storage of small's, a cost that repeats every month rather than once.
Batch pricing and what it changes
If you submit the work as a Batch job, small drops to $0.01 per million tokens and large to $0.065, exactly half the standard rate.
The trade is timing: you submit Batch jobs as a file and get results back asynchronously, so they suit backfills and scheduled refreshes rather than a user waiting on a search box.
When a client's changed documents are re-embedded nightly, that job belongs on Batch. Only live queries should pay the standard rate.
Token costs across usage volumes
At $0.02 per million tokens on the small embedding model and $0.13 on the large one at standard rates, the three workloads below range from pennies to four figures. The table prices each at both sizes and both rates.
| Workload | Estimated tokens | Small, standard | Small, Batch | Large, standard | Large, Batch |
|---|---|---|---|---|---|
| 10,000-page help centre | 7M | $0.14 | $0.07 | $0.91 | $0.46 |
| 5M-document archive | 10B | $200 | $100 | $1,300 | $650 |
| 1M monthly queries | 20M | $0.40 | n/a, live | $2.60 | n/a, live |
Assumptions: about 700 tokens per help page, about 2,000 per archive document and about 20 per search query.
Embedding costs for a small knowledge base
Under a dollar buys the whole help centre, even on the large model at standard rates.
A weekly full refresh on the large model comes to roughly $47 a year.
For 100M tokens, the embeddingcost.com figure is $2 to $13 at standard price, which covers about fourteen help centres of this size, so each centre's embeddings cost under a dollar.
Embedding costs for a large archive
At 1B tokens the same source gives $20 to $130 at standard price, and at 10B tokens $200 to $1,300, making larger deployments genuinely expensive. The archive sits at the top of that range.
Pick large over small and the whole bill is multiplied by 6.5.
Batch halves it again, so the large model at standard rates costs 13 times the small model on Batch. A single full re-index on the large model is $1,300 if done live and $650 if queued.
On a shared account that spend lands on whoever holds the key, so everyone who doesn't re-index subsidises the client who re-indexes twice a quarter. Give that client a separate key, or bill the re-index as its own line.
Monthly query embedding costs at scale
Run a million searches and you embed about 20M tokens, which is $0.40 on the small model and $2.60 on the large one.
These queries pay the standard rate regardless, and the amount is too small to matter. What follows from this is that the model decision belongs to the archive, because query-time cost barely changes with it.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Hidden OpenAI embeddings costs and rate limits
You pay again each time the archive is rebuilt, padded, stored and throttled, and the token price shows none of it. Five drivers do most of the damage:
- Re-embedding after document edits
- Re-embedding after a model change
- Chunk overlap inflating the token count
- Storage growing with vector dimensions
- Usage-tier rate limits and per-request input caps
A quote built on list price alone misses all five.
Re-embedding and chunk overlap
It is easy to approve one full pass over the archive at $130 on text-embedding-3-large and $20 on text-embedding-3-small, but it's the cheapest the archive will ever be.
Thirty passes reach $3,900 on large against $600 on small. A daily rebuild on large costs $3,300 more than small.
To fix this, re-embed only chunks that changed. A model change is the exception: vectors from different models can't be compared, so you have to redo the whole archive.
Overlap compounds this. Chunks that repeat 20% of their neighbour add 20% to the tokens in every pass, and the surcharge repeats with each rerun.
Vector storage costs by embedding dimensions
By default, text-embedding-3-large returns 3,072 values per vector. Small returns 1,536. At four bytes each, a million chunks take about 12 GB on large and 6 GB on small, before index overhead.
Because each input has a cap of 8,192 tokens, long documents must be chunked whatever your strategy.
Throughput depends on your usage tier, which rises with account spend. A new account running a big rebuild can be throttled for hours, and a rebuild that fails partway gets paid for twice.
OpenAI embeddings vs Cohere, Google and Voyage
Because every hosted alternative bills per token the way OpenAI does, changing vendor moves your invoice far less than changing the schedule, the overlap or the storage you just budgeted.
Hosted API alternatives compared
Read this table for the billing shape, not just the rate.
Because every hosted alternative bills per token the way OpenAI does, changing vendor moves your invoice far less than changing the schedule, the overlap or the storage you just budgeted.
A free tier helps you prototype but doesn't belong in a client's recurring quote, and a batch discount only pays off if your re-embedding can wait.
| Option | How you are billed | Rate in this article | Free tier or batch discount |
|---|---|---|---|
| OpenAI 3-small | Per token | Published on OpenAI's pricing page | Batch discount available |
| OpenAI 3-large | Per token | Published on OpenAI's pricing page | Batch discount available |
| Cohere Embed v4 | Per token | $0.12 per 1M tokens | Trial access for testing |
| Google Gemini Embedding | Per token | Published on Google's pricing page | Free tier for testing |
| Voyage AI | Per token | Published on Voyage's pricing page | Free token allowance for testing |
| Self-hosted open model | Per GPU hour, not per token | Your own hardware or rental cost | None; you carry the idle time |
Between the hosted vendors, the rate is rarely what decides it. Input length and dimensions decide it, since longer vectors raise your storage bill every month, and a model that forces smaller chunks raises how many calls you make.
Self-hosting open models
You pay for the GPU hours whether or not anyone embeds anything, so self-hosting only wins when you keep it busy.
A client who re-embeds a large corpus every night can justify a dedicated machine.
A client who adds a few documents a week is being cross-subsidized by every other job on the box, and should be quoted on the API instead.
Count the labor too. Someone has to patch the server, watch the queue and re-run jobs that fail, and that time belongs on the invoice as a line of its own.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
Keep embeddings current without re-embedding everything
Re-embed only what changed, on a schedule you can bill for, and the cheap per-token price stays cheap instead of being quietly absorbed by your own account.
- Measure your monthly tokens: count what you embed now, split by client or project.
- Test the small and large embedding models on a sample of real documents, and keep the large one only where retrieval quality visibly improves.
- Route bulk jobs, such as first loads and full rebuilds, through the Batch API, which is meant for work nobody is waiting on.
- Hash each chunk and embed only the ones whose hash changed.
- Schedule the refresh so it runs at a set cadence instead of whenever someone remembers.
Audit your token volume first
Pull the count from your usage logs, not from the number of documents, because a handful of long manuals can outweigh thousands of short notes.
One shared key hides which client's content is driving the spend. Separate keys or projects per client turn that into a line you can put on an invoice.
Run the sample test in the same pass. If the small model retrieves the right passages for a given client's content, the large model is an upgrade that client has to be asked to pay for, not a default you carry for them.
Embed only what changed
Store a hash of each chunk's text next to its vector. On each refresh, re-chunk the source, compute the hashes, and compare them with what you stored. Send only new or altered chunks for embedding, and delete the vectors for chunks that no longer exist.
A full rebuild then becomes rare, needed only when you switch models or change your chunking rules.
If an edit near the top of a document shifts every chunk below it, every hash changes and you pay for the whole file again.
That's why chunk boundaries decide how well this works: split on headings or paragraphs, not fixed lengths, so a small edit stays a small bill.
The cadence should match how quickly each client's content actually goes stale, and a client who wants fresher data than that cadence should be charged for the extra runs.
What Activepieces does about this
The costs above come from how often you re-embed and which model you pick, so what matters is whether your tooling lets you control both.
In Activepieces you build the refresh as a flow: a schedule trigger sets the cadence, a step compares chunk hashes against what you stored, and only the changed chunks go to the OpenAI step.
The full-archive pass becomes a deliberate run you start yourself, not something that happens every night.
The model and the bill stay with you. The OpenAI step uses your own key, so small or large is your call and the tokens are billed at the rate on OpenAI's page. On Plus and up, bring-your-own-key makes each AI step 1 credit.
If you give each client a separate OpenAI project and key, as recommended above, each client's embedding spend shows up as its own line.
The core is open source under the MIT licence, so you can self-host the flows and read how they run before you quote anyone. MoneyGram, Moneypenny, Alan and FundingSocieties run it in production.
Start with one client: build the hash-and-diff flow, run it for a month, and compare your OpenAI usage for that project with the estimate in the table.
Frequently asked questions
Once the cadence is settled, a handful of billing questions remain, and each one decides whether a client's line on the invoice matches what their runs cost you.
Is there a free tier for OpenAI embeddings?
Don't plan on one. Embeddings are billed per token through the API, and any trial credit on a new account is a one-time cushion, not a recurring allowance.
If you fold a credit into a client quote, the second month's invoice will be short, so price from the published rate and treat credit as a bonus.
Can I reduce dimensions to save on storage?
Yes, with the current text-embedding-3 models, which accept a dimensions setting that returns shorter vectors. That cuts what you pay your vector database for storage and search, but it doesn't cut the embedding bill, because you are charged for the input tokens either way.
Test on the client's own queries before shrinking an index you have already promised them, because shorter vectors give up some retrieval quality.
Do I have to re-embed if OpenAI releases a new model?
Only if you want to move to it. Existing vectors keep working with the model that made them, but vectors from two different models can't be compared with each other.
Switching therefore means re-embedding the entire corpus and rebuilding the index, which is a project in its own right.
Quote it as a separate line item, not as part of the monthly run, and don't absorb it quietly for a client who never asked for the upgrade.
How do I track embedding spend?
Give each client their own project and API key, then read usage per project in OpenAI's dashboard. This is the one habit that stops a shared account from hiding a heavy client inside an average.
Set a spending limit per project as well, so a runaway re-embed trips an alert before it becomes a surprise you carry.
Pull the per-project figures at the same moment you build the invoice, so what you bill and what you spent come from one source.
No, ChatGPT Plus billing isn't the same as API billing. A ChatGPT subscription and API usage are separate products with separate billing, and the subscription doesn't pay for API calls.
A client who says they already pay OpenAI is almost certainly describing the chat subscription, so the embedding spend still lands on whichever account holds your API key.
Related reading
References
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
