# What Are Embeddings? A Plain-English Guide for Founders

> Embeddings turn text into vectors so software can measure meaning. What they power, how cosine similarity works, what they cost and how to ship semantic search.

- Canonical: https://zeroraised.com/blog/what-are-embeddings
- Published: 2026-11-01T09:20:09Z
- Author: ZeroRaised Team (https://zeroraised.com/blog/authors/zeroraised)
- Publisher: ZeroRaised (https://zeroraised.com/)
- Section: Growth
- Tags: artificial-intelligence, developer-tools, saas, bootstrapping

An embedding is a vector, or list of floating point numbers, that represents a piece of text so that software can measure relatedness ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)). Small distances between vectors suggest high relatedness. That idea powers search, recommendations and classification at a price an indie product can afford.

**TL;DR**

- An embedding is a list of numbers representing text, where nearby vectors mean similar meaning.
- Embeddings power search, recommendations, clustering, classification, anomaly detection and diversity measurement.
- OpenAI's text-embedding-3-small uses 1,536 dimensions by default, 3-large uses 3,072, and both can be shortened.
- Prices are $0.02 per million input tokens for 3-small and $0.13 for 3-large.
- Ship semantic search with cosine similarity, a sensible chunking plan and retrieval tests on real questions.

**Disclosure:** ZeroRaised publishes this analysis and is a launch site for bootstrapped products. Facts come from the linked sources as checked on 1 Nov 2026; ZeroRaised has no commercial relationship with the companies named.

**An embedding** is a vector of floating point numbers that represents a piece of text, so that a program can compare two texts by measuring the distance between their vectors rather than by matching words.

## What are embeddings used for?

OpenAI lists the main uses as search, clustering, recommendations, anomaly detection, diversity measurement and classification ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)). Each one is a variation on the same move: turn content into vectors, then compare them.

- **Search:** find passages whose meaning is close to the query, even when the wording differs.
- **Recommendations:** suggest items near the ones a user already likes.
- **Clustering:** group similar support tickets, reviews or documents without hand-written rules.
- **Classification:** label content by its nearest known examples.
- **Anomaly detection:** flag items that sit far from everything else.

## How does cosine similarity work?

A vector has a direction and a length. Cosine similarity compares directions, so it asks how closely two vectors point the same way. OpenAI recommends cosine similarity for its embeddings and says its models output vectors normalised to length 1 ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)). With unit-length vectors, the dot product gives the cosine similarity directly.

The practical rules are simple. Use the same embedding model for documents and queries, because vectors from different models do not share a space. Pick one distance metric and use it everywhere, so scores stay comparable across your index.

## How many dimensions do you need?

OpenAI's text-embedding-3-small defaults to 1,536 dimensions and text-embedding-3-large to 3,072. The `dimensions` parameter shortens them without changing the model ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)).

Shorter is not automatically worse. OpenAI reports that text-embedding-3-large shortened to 256 dimensions still outperforms an unshortened text-embedding-ada-002 at 1,536 dimensions on MTEB. The same guide gives MTEB scores of 62.3% for 3-small, 64.6% for 3-large and 61.0% for ada-002, with a maximum input of 8,192 tokens ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)).

The trade-off is storage and speed against recall. Start at the default, then measure a shorter version on your own queries. If quality holds, keep the smaller index.

## What do embeddings cost?

OpenAI charges $0.02 per million input tokens for text-embedding-3-small and $0.13 per million input tokens for text-embedding-3-large ([OpenAI's API pricing](https://developers.openai.com/api/docs/pricing)). That is cheap next to generation, but it is not free at scale.

The same guide translates price into pages at about 800 tokens per page: 62,500 pages per dollar for 3-small, 9,615 for 3-large and 12,500 for ada-002 ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)).

The cost that surprises people is re-embedding. Every time you change a chunking rule or switch models, the whole corpus has to be processed again. Keep the source text and the embedding version, so a migration is a job you can rerun rather than a mystery.

## What about multimodal and multilingual embeddings?

Gemini's gemini-embedding-2 is the first multimodal embedding model in the Gemini API. It places text, images, video, audio and documents in a unified embedding space, across more than 100 languages ([Gemini API embeddings](https://ai.google.dev/gemini-api/docs/embeddings)).

For text-only work, gemini-embedding-001 is still available and supports a `task_type`, such as `SEMANTIC_SIMILARITY`. gemini-embedding-2 does not use `task_type`; you include the task as an instruction instead ([Gemini API embeddings](https://ai.google.dev/gemini-api/docs/embeddings)).

## How do you ship semantic search in a SaaS?

1. **Collect real questions.** Take them from support, sales calls and search logs. These become your test set before they become features.
2. **Chunk with care.** Split documents into passages of a few hundred tokens with a little overlap, and keep a link back to the parent document.
3. **Embed once, store the version.** Write the model name and dimension count next to every vector so a later migration is possible.
4. **Query with the same model.** Embed the user's question, then rank passages by cosine similarity.
5. **Add keyword search.** Combine semantic results with exact matching so product names and error codes are not lost.
6. **Put a language model on top.** Feed the best passages into a prompt to write the answer. The [guide to RAG](https://zeroraised.com/blog/what-is-rag) covers that half of the system.
7. **Test and log.** Measure whether the right passage appears in the top five, then log failures with the query that caused them.

## What are the common mistakes?

- **Chunks that are too large.** A 5,000 token chunk embeds several ideas and matches none of them well.
- **Ignoring exact terms.** Semantic search can miss a SKU, an error code or a person's name that keyword search would catch.
- **Assuming freshness.** OpenAI says its v3 embedding models lack knowledge of events after September 2021 ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)). The model does not know your new product; it only knows the text you send it.
- **Skipping evaluation.** A demo with five happy examples is not evidence that retrieval works.

## What this means for bootstrapped founders

Embeddings are a building block, not a business. The defensible part is the corpus, the chunking rules and the feedback loop, not the API call.

Treat embedding cost as a small, predictable line item. The [guide to reducing LLM costs](https://zeroraised.com/blog/how-to-reduce-llm-costs) covers the bigger levers, and the [guide to choosing an LLM API](https://zeroraised.com/blog/how-to-choose-an-llm-api) helps you compare providers on price and behaviour. If you are adding search to an existing product, the [guide to adding AI features to a SaaS](https://zeroraised.com/blog/how-to-add-ai-features-to-a-saas) covers the packaging question.

Two rules keep the work honest. Ship retrieval quality before a chat interface: a fluent answer built on bad passages is worse than a list of links. Check your data terms too: OpenAI says customers own their inputs and outputs, including embeddings ([OpenAI's embeddings guide](https://developers.openai.com/api/docs/guides/embeddings)), but read the terms before sending customer content.

## Where ZeroRaised fits

ZeroRaised is a launch and discovery site for products built without institutional venture capital or accelerator equity. If you have shipped a search, support or research feature on embeddings, [submit it here](https://zeroraised.com/submit) and describe what it does in plain language. The [pricing page](https://zeroraised.com/pricing) explains the current options.

For more practical guides, [join the ZeroRaised newsletter](https://zeroraised.com/newsletter). We make no promise of traffic or results.

## Sources

- [OpenAI: Vector embeddings](https://developers.openai.com/api/docs/guides/embeddings)
- [OpenAI: API pricing](https://developers.openai.com/api/docs/pricing)
- [Gemini API: Embeddings](https://ai.google.dev/gemini-api/docs/embeddings)

## Frequently asked questions

### What is an embedding in plain English?

It is a list of numbers that represents a piece of text. Text with similar meaning produces vectors that sit close together, so a program can compare distances instead of matching exact words. That is what makes semantic search possible when a user types a phrase the page never uses.

### Are embeddings the same as a large language model?

No. An embedding model turns text into numbers. A generative model produces text. Products often use both: embeddings to find the relevant passages, then a language model to write the answer from them. That combination is the core of retrieval augmented generation.

### How many dimensions should I use?

Start with the provider default, then test a shorter version against your own questions. OpenAI lets you shorten embeddings with the dimensions parameter, and it says text-embedding-3-large shortened to 256 dimensions still outperformed an unshortened text-embedding-ada-002 at 1,536 dimensions on MTEB. Fewer dimensions save storage and speed up search, but the only test that matters is retrieval quality on your data.

### Do I need a vector database?

Not at the start. OpenAI recommends a vector database when you have many vectors, but a small product can often keep embeddings in its existing database and scan them. Move when query latency or volume makes the scan slow, not because a diagram says so.

### What do embeddings cost?

OpenAI charges $0.02 per million input tokens for text-embedding-3-small and $0.13 for text-embedding-3-large. At roughly 800 tokens per page, that is 62,500 pages per dollar on 3-small and 9,615 pages per dollar on 3-large. The catch is that you pay again when you re-embed changed content.