bge-m3 vs OpenAI text-embedding-3: which embedding model, and why

Neither model sweeps this question. OpenAI's text-embedding-3 pair is the closed pick: no downloadable weights, official dimension shortening, one vendor. bge-m3 is the open pick: MIT weights, 100+ languages, three retrieval outputs from one pass, and it runs on your GPU or a hosted route. Cost does not break the tie. Control does.

Every number below names its owner and its date. The model facts come from BAAI's model card and BAAI's documentation, read 28 October 2026. The OpenAI facts come from its embeddings guide and its launch post, read the same day. Third-party rows are labeled third-party and dated. Where nothing verified exists, the cell stays a dash. The pages ranking today mix publisher scores with undisclosed arena runs, and they never say which is which. This page keeps the two apart.

Last verified: 2026-10-28

The questions behind the query

The query has a shape, and it is a buyer mid-decision. Search completions for "bge-m3 vs" expand into nine follow-ons, from qwen3-embedding to nomic-embed-text, captured 26 October 2026. Google attaches four questions to the family, captured the same day. Two of them: "Which is the best text embedding model?" and "What is the best OpenAI embedding model?" Dedicated head-to-head pages hold the top ranks. Three demand signals, one message: the market is choosing, and the current results are not settling it.

Five questions sit underneath. Does quality favor one side. What does each cost. Can you shrink the vectors. Who can host each model. And what happens when you want to switch later. The rest of this page answers each in order, with sources.

The one-table verdict

Two rows carry the whole decision. First, retrieval outputs: bge-m3 produces a dense vector, sparse keyword weights, and per-token multi-vectors from a single pass, while text-embedding-3 returns dense vectors only. Second, weights: bge-m3's travel under MIT, and text-embedding-3's do not exist outside OpenAI's API. Everything else in the table is a detail on those two forks.

Same month, two different bets

The two models shipped within weeks of each other, on opposite bets. OpenAI announced the text-embedding-3 pair on 25 January 2024. BAAI's repository landed the same month, with the technical report following on 5 February 2024 and still receiving updates as recently as December 2025.

BAAI bet on one model doing three jobs. The BAAI documentation prints the scoring math. A dense vector comes from the first token's hidden state. Sparse lexical weights come per vocabulary token. ColBERT-style multi-vectors score by late interaction. All three come out of one encoder pass, trained together through self-knowledge distillation, per the technical report. The point is hybrid search from one model: semantic matching plus learned keyword matching, in the same response.

OpenAI bet on one output whose size you control. Both v3 models were trained so you can shorten vectors by passing a dimensions parameter. The trade is some accuracy for smaller storage. OpenAI's own table has the striking row: text-embedding-3-large shortened to 256 dimensions still outscores the old ada-002 model at its full 1,536 dimensions. Manual truncation works too, but you must re-normalize the vector afterward.

Neither bet is a gimmick. If your corpus is multilingual or full of product codes and rare names, the sparse output matters. If your storage bill scales with vector width, shortening matters. Most teams only need one of the two, and that is usually the fork.

The spec sheet, owner by owner

The dimension row first, because storage math hangs on it. bge-m3 emits a fixed 1,024-float dense vector; its card prints no truncation training, so treat 1,024 as the working number. text-embedding-3-small defaults to 1,536 and large to 3,072, and both shorten officially. One float32 vector costs 4 bytes per dimension, so a million native vectors cost about 4 GB of raw storage for bge-m3, about 6 GB for small, about 12 GB for large. Shorten large to 1,024 dimensions and it also lands at 4 GB, at some accuracy cost by OpenAI's own table.

Context length is a tie, with a footnote. Both sides publish 8,192 tokens of maximum input. OpenAI's own table says 8,192; some third-party pages circulate 8,191 from the API's hard rejection boundary. Trust the published table and keep inputs under 8,192.

Languages split by claim type. BAAI gives a count: more than 100 working languages, trained on data covering up to 170+, with BAAI's own caveat that coverage is unbalanced. OpenAI posts no count. Its multilingual evidence is a score: the MIRACL benchmark, where large averages 54.9 and small 44.0 in the 2024 test. Effective-language counts for either vendor: dash. Nobody verified one.

Usage is measurable only on the open side. The bge-m3 repository counted about 30.1 million downloads in the last month, read 28 October 2026. Ollama, the local-runtime host, counted 8 million pulls. OpenAI publishes no usage for its embedding models, so that row cannot exist for them.

What the scores actually say

Start with what each publisher claims about its own model, because those claims are comparable only in kind, not in number.

Two honesty notes on that table. OpenAI's numbers are its own 2024 test, not a neutral run. And BAAI corrected its MIRACL chart in July 2024 after a search-results error. The conclusion held; the data got fixed. That is the kind of correction you want from a publisher.

Third-party runs, each dated and attributed:

• On English retrieval, an independent benchmark published 3 May 2026 measured NDCG@10 of 0.847 for text-embedding-3-large against 0.831 for bge-m3 on technical documentation, with bge-m3 degrading less when the domain shifted (3.4 percent against 6.6 percent). One author, one A100, English corpora only: direction, not gospel.
• On the multilingual MTEB average, a benchmark roundup updated 23 October 2026 reads bge-m3 at 59.56.
• On the 2026 frontier, neither model leads. Qwen3-Embedding-8B has held the top of the multilingual MTEB board since June 2025 at 70.58, per Qwen's own model card. Newer open families score higher than both of our subjects.

So the honest verdict on quality: on English retrieval the two sit close. The large model leads on its publisher's table and in the one dated independent run. On multilingual and long-document work, bge-m3 carries the stronger published story. On raw 2026 leaderboard position, both are two years old and beaten by newer families. If a page hands you one winner without saying which evidence class it used, it has flattened exactly this table.

The cost shape

Embedding cost has three shapes, and they do not compare head to head.

The first shape is a hosted per-token route. This platform serves bge-m3 on its embeddings route, metered per token against a prepaid wallet. The wallet balance is the hard stop: a refused request bills nothing.

The worked math, on named variables:

monthly cost  =  ( T / 1,000,000 ) x R

T:  tokens embedded in the month, first pass plus any re-embed of the corpus
R:  per-million-token rate from the fenced row above

One sensitivity note that surprises teams: chunk overlap inflates the billed token count by 10 to 25 percent, per a third-party embedding cost calculator with September 2026 prices. Budget T with that in mind. One metering detail measured on this lane: requests of a few tokens can round to zero at ledger precision. Tiny smoke tests are effectively free.

The second shape is OpenAI's per-token route, and this page states it as relations, not numbers. Per OpenAI's model pages, read 28 October 2026, the small model's per-million-token rate sits below this platform's embeddings rate. The large model's sits above it. The pair brackets ours. The same third-party calculator reports OpenAI's Batch API roughly halves its embedding rates for non-urgent work. The pricing guide carries this platform's live rates, always current.

The third shape is self-hosting, where the per-token bill is zero and the hardware bill is not. The MIT license makes the weights free to run on hardware you own or rent. That same calculator put the crossover near 15 million tokens per month on rented spot hardware, September 2026 numbers. That is before operator time and idle machine hours. Under that volume, hosted usually wins on cash. Over it, the hardware starts paying for itself, and bge-m3 is the only model on this page that gives you the choice.

Control: who can leave, and what it costs

The axis nobody ranks on is the one that decides multi-year projects.

bge-m3's weights travel. Run them through BAAI's FlagEmbedding toolkit for all three output types, through Ollama as a 1.2 GB local build, or through any GGUF-compatible server. The same weights can move between your laptop, your cluster, and a hosted route, and the license never changes. If a vendor disappears or a price jumps, your index and your model survive.

text-embedding-3 has no weights to take home. It exists only behind OpenAI's endpoint. Every vector in your index came from a model you can never run yourself. Any future change, price, policy, or deprecation, means re-embedding the whole corpus at whatever the next vendor charges. OpenAI kept ada-002 available after launching v3, which softens the near-term risk. It does not remove the structural one.

One warning that applies the moment you exercise the open side. Community reports, and this platform's own documentation, record the same bge-m3 weights producing vectors that differ in scale between two local runtimes. Never mix vectors from two runtimes into one index. Pick one runtime per index, and if you switch, re-embed the corpus rather than migrating vectors.

Who serves each model today

OpenAI serves its pair through one endpoint, /v1/embeddings, with usage tiers. The published free tier allows 100 requests per minute and 2,000 per day, per OpenAI's model page read 28 October 2026. Build tiers raise those limits.

bge-m3 reaches you through four routes. Self-host, the three ways named above. A third-party model marketplace lists it from two providers, read 28 October 2026. And this platform, which serves it on the embeddings route as of 28 October 2026, per token, alongside a multimodal sibling in the same lane. The lane is young. One real request through it returned a 200 with a ledger-matched usage row on 9 September 2026. In the 28 August 2026 window, median latency ran 1.38 seconds single-flight and 1.90 seconds at the measured 8-in-flight ceiling, with 32 concurrent requests pushing the median to 4.33 seconds. Read those as planning inputs from that window, not as promises. The bge-m3 model page carries the full request contract, and the models index is the live catalog.

Make the first call

The whole choice collapses into one request. Sign up, create a key, and run:

curl -X POST "https://api.ironstratum.com/v1/embeddings" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bge-m3",
    "input": [
      "bge-m3 maps text to a 1024-dimension vector for retrieval.",
      "text-embedding-3-large maps text to a 3072-dimension vector."
    ],
    "encoding_format": "float"
  }'

The response proves the key, the route, and the model in one round trip. The usage block is the metering record your bill will match. Each vector comes back 1,024 floats long. From there the work is your vector store, not the API. The OpenAI-compatible API guide covers the wider request surface, and the pricing page settles the budget question before you scale.

Choose in 60 seconds

Work down the list and stop at the first fit.

1. The corpus spans languages, or queries cross language lines: bge-m3.
2. You want semantic plus keyword retrieval from one model, no second system: bge-m3.
3. The weights must stay on hardware you control, or procurement needs an MIT license: bge-m3.
4. You want zero operational surface and already build on OpenAI APIs: text-embedding-3.
5. Storage is the constraint and you want the large model's quality at small-vector prices: text-embedding-3-large, shortened through dimensions.
6. English-first retrieval, and you want the higher publisher-published score: text-embedding-3-large.
7. You are chasing the 2026 leaderboard rather than these two: start with Qwen3-Embedding, then re-run this comparison.

Common questions

Which is better for RAG? The workload decides, not a score. Multilingual corpus, hybrid retrieval, or a license constraint: bge-m3. English-first, ops-averse, already on OpenAI: text-embedding-3. On English retrieval quality the two sit close, per the dated runs above, so cost and control should finish the decision.

Which one handles more languages? bge-m3 publishes a count, 100+ working languages with training coverage up to 170+, and BAAI itself says coverage is unbalanced. OpenAI publishes no count, only multilingual benchmark scores. A verified side-by-side count does not exist, so this page prints none.

Can I shrink the vectors? On text-embedding-3, yes, officially: pass dimensions at request time, and OpenAI's table says large at 256 dimensions still beats old ada-002 at 1,536. On bge-m3, no truncation training is published; cutting a 1,024 vector short yourself loses quality with no vendor support. The storage math for both is in the spec section.

Is bge-m3 as accurate as OpenAI's models? Close on English, by the one dated independent run (0.831 against 0.847 NDCG@10 on technical docs), and stronger on multilingual and long documents by BAAI's scoped claims. The publisher tables use different comparison sets and cannot be subtracted from each other. Test on your own corpus before committing; every methodology-aware source says the same thing.

What does each cost to run? This platform's rate renders on the pricing page, metered per token with a prepaid wallet as the ceiling. OpenAI's rates are stated here only as relations: the small model under ours, the large model over ours, bracketing it, per its own pages read 28 October 2026. Self-hosting removes the per-token bill and adds a hardware bill, with a third-party crossover estimate near 15 million tokens per month on rented spot hardware.

Can I switch models later without re-embedding? No. Every embedding model produces its own vector space, and vectors from two models cannot be mixed or compared. Switching means re-embedding the corpus. The asymmetry is in the exit: bge-m3 users can re-embed on hardware they already run; text-embedding-3 users re-embed by paying whatever API then exists. Plan the index around the model you trust for the corpus's lifetime.

The short version

Pick by workload, then by control. bge-m3: open MIT weights, three retrieval outputs, 100+ languages, self-host or hosted, and this platform serves it per token today. text-embedding-3: closed and convenient, official dimension shortening, one vendor, rates that bracket ours. Neither leads the 2026 leaderboards; newer open families do. The embeddings lane page maps the route family. The bge-m3 model page holds the working contract. The pdf-to-markdown guide covers the ingestion step that feeds any index. The live rates sit on the pricing page. When you are ready, sign up and create a key without talking to anyone.

Last verified: 2026-10-28