Cost-effective text embedding model from OpenAI, ideal for semantic search and clustering, accessed via OrcaRouter at zero markup.
openai/text-embedding-3-small is an embedding model released by OpenAI in January 2024. It produces vector representations of text that capture semantic meaning, enabling comparison and similarity…
This model performs strongly on tasks that require capturing overall meaning rather than fine-grained details. It is widely used for semantic search, where queries are embedded and matched against a corpus of document embeddings. It also works well for clustering—grouping similar texts without explicit labels—and for classification when embeddings are fed into a linear classifier. In retrieval-augmented generation (RAG) pipelines, it efficiently encodes both queries and documents, enabling fast similarity-based retrieval. Its 8,192-token context allows it to process longer passages, such as research abstracts or customer feedback, in a single embedding call.
If your use case involves very short texts (e.g., single words or phrases) or you prioritize speed over accuracy, you might explore even more lightweight models from other providers available on OrcaRouter, such as those with lower dimensionality or specialized for specific languages. Additionally, if your task is extremely coarse—like distinguishing only between a few broad categories—a simpler model may suffice. However, openai/text-embedding-3-small is already one of the most affordable options from OpenAI. For applications where embedding quality directly impacts downstream performance (e.g., ranking for search), the small added cost often justifies the better results compared to the free-tier alternatives.
OpenAI's text-embedding-3-small has demonstrated strong cross-lingual capabilities, performing well on multilingual benchmarks such as MTEB's multilingual subsets. It can embed text in dozens of languages and produce comparable vectors for similar content across languages. This makes it useful for global applications like international product recommendation or multilingual support ticket routing. However, for specialized domains (e.g., legal, medical, code), a domain-adapted embedding model might yield higher accuracy. If your data is highly technical, you may want to benchmark this model against alternatives to ensure optimal performance.
According to publicly available results, openai/text-embedding-3-small achieves a mean score around 62% on the MTEB benchmark (Massive Text Embedding Benchmark). This reflects solid performance across a variety of tasks including classification, clustering, pair classification, and reranking. While it trails the larger text-embedding-3-large (which scores around 65%), its cost per token is roughly one-tenth that of the large variant. The model's performance is particularly strong on clustering and semantic similarity tasks. For tasks requiring high precision in STS (Semantic Textual Similarity), the small model still performs competitively.
Latency for embedding requests depends on input length and concurrent load. On OrcaRouter, the model is served via OpenAI's infrastructure, so typical latencies are comparable to direct OpenAI API calls. For a single query of average length (100-200 tokens), response time is generally under 200ms. Throughput can be increased by batching multiple texts in one API call. The model supports batch processing, and OrcaRouter passes the same batching parameters as the OpenAI API. For high-volume workloads, the low cost per token makes it feasible to embed millions of records without breaking budgets.
Despite its strengths, openai/text-embedding-3-small has limitations. Its 512-dimensional default vector may lose some nuance compared to the 1,536-dimension large variant, especially for fine-grained semantic distinctions. The model's performance on tasks requiring deep domain knowledge or handling of very long documents (near 8,192 tokens) can degrade if the text is noisy or poorly structured. Additionally, because it is a general-purpose model, it may underperform on specialized tasks like code search or biomedical concept extraction compared to dedicated models. OrcaRouter provides access to other models for those specific needs.
openai/text-embedding-3-small is priced at $0.02 per million input tokens and $0.02 per million output tokens. Because the model only produces embeddings (output tokens are the vector representation, not text), the output token count is proportional to the input. In practice, you are billed for both input and output tokens at the same rate. OrcaRouter passes through the exact provider rate with zero markup, so the total cost is exactly $0.02 per million input tokens and $0.02 per million output tokens. There are no additional platform fees or hidden charges. This makes the model one of the most cost-effective options for embedding text at scale.
Compared to OpenAI's text-embedding-3-large ($0.13 per 1M input tokens), the small model is 6.5x cheaper. For many applications, the performance degradation is modest, making the small model a better value. Compared to legacy ada-002 (now deprecated), the small model is both cheaper and more capable. On OrcaRouter, you can also find third-party embedding models with even lower prices; however, they may not offer the same quality or compatibility with OpenAI's ecosystem. The zero-markup model from OrcaRouter ensures you pay only what you would directly, without any premium.
OrcaRouter may implement caching mechanisms to reduce redundant API calls. If you send the same input text multiple times, the platform might return cached embeddings without incurring additional token costs. However, caching policies are not explicitly detailed in the provided facts. To minimize costs, you can implement your own caching layer on the client side using the returned embedding vectors. Since the token cost is already very low, caching provides marginal savings unless you have extremely repetitive queries. Contact OrcaRouter support for details on server-side caching behavior.
To use openai/text-embedding-3-small via OrcaRouter, set the base URL to https://api.orcarouter.ai/v1 and specify the model ID as 'openai/text-embedding-3-small'. The API is fully compatible with OpenAI's embedding endpoint, so you can use the OpenAI Python library or any HTTP client with the same request format. For example, in Python: client = OpenAI(base_url='https://api.orcarouter.ai/v1', api_key='your_key'); response = client.embeddings.create(model='openai/text-embedding-3-small', input='Your text here'). The response contains the embedding vector and usage details.
The API supports the same parameters as OpenAI's embedding endpoint. Required: 'model' set to 'openai/text-embedding-3-small' and 'input' (string or array of strings). Optional: 'dimensions' (integer, 128 to 512, default 512) to reduce the output vector size. A smaller dimension speeds up downstream processing and reduces storage while retaining most of the semantic information. The 'user' parameter can be used for rate limiting per customer. OrcaRouter also accepts standard headers like Authorization and Content-Type. For batch requests, pass an array of strings as input; the API will return a list of embeddings in corresponding order.
If you currently use OpenAI's embedding API, migrating to OrcaRouter is straightforward. Change the base URL from https://api.openai.com/v1 to https://api.orcarouter.ai/v1, and update the model name to 'openai/text-embedding-3-small'. No other code changes are required. Your existing client library (Python, Node.js, curl, etc.) will work identically. OrcaRouter supports the same authentication scheme using an API key. This switch allows you to benefit from zero-markup pricing without retooling your embedding pipeline. Ensure your key has access to the model on OrcaRouter.
The primary differences are size, cost, and performance. text-embedding-3-large outputs 1,536 dimensions (default) versus 512 for the small version, and costs $0.13 per 1M input tokens—6.5x more expensive. On the MTEB benchmark, large scores about 65%, small about 62%. For most applications, the small model offers a better value-to-cost ratio. The large model may be preferred when you need the highest possible accuracy for tasks like fine-grained similarity search or when you cannot afford any drop in recall. OrcaRouter provides both models, so you can test both on your own data.
OpenAI's previous embedding model, text-embedding-ada-002, is now deprecated and no longer available through official channels. Compared to ada-002, text-embedding-3-small offers better average performance on MTEB (62% vs ~61%), supports a larger context (8,192 vs 2,048 tokens), and costs significantly less ($0.02 vs $0.10 per 1M input tokens) at current pricing. The new model also introduces the dimensions parameter, allowing further cost and storage optimization. If you have workflows still using ada-002, you should migrate to text-embedding-3-small for improved quality and lower cost.
OrcaRouter hosts embedding models from multiple providers, varying in price, dimension, and quality. For instance, some models offer free tiers or lower per-token costs. However, those models often have smaller context windows (e.g., 512 tokens) or lower benchmark scores. openai/text-embedding-3-small balances cost, context length, and quality. If your data is highly domain-specific, a bespoke model (e.g., code- or legal-specific) might outperform it. OrcaRouter's catalog lets you compare performance and pricing. The small model is a reliable default for general-purpose English and multilingual tasks.
Open-source embedding models (e.g., from Hugging Face) can be self-hosted, potentially reducing cost at very high volumes. However, they require infrastructure, maintenance, and expertise to achieve latency and reliability comparable to OpenAI's API. openai/text-embedding-3-small, accessed via OrcaRouter, offers zero infrastructure overhead, consistent uptime, and compatibility with the OpenAI ecosystem. For small to medium-scale workloads, the managed API is often more economical when factoring in engineering time. For extremely large-scale deployments (billions of embeddings), self-hosted models may become cheaper, though the quality parity is not guaranteed.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1dimensionsencoding_format| Input / 1M tokens | $0.020 |
|---|---|
| Output / 1M tokens | $0.020 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
Compare monthly costs across models in the LLM cost calculator
What developers are saying this week
GET /api/public/models/openai/text-embedding-3-smallOpen @misc{orcarouter_text_embedding_3_small,
title = {openai/text-embedding-3-small API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/text-embedding-3-small}
}openai. (n.d.). openai/text-embedding-3-small API. OrcaRouter. https://www.orcarouter.ai/models/openai/text-embedding-3-small