High-quality text embeddings via OrcaRouter at $0.13/M tokens, zero markup, up to 3072 dimensions.
OpenAI text-embedding-3-large is a large-scale embedding model from the third generation of OpenAI’s text embedding series. It converts text input into dense vector representations that capture…
text-embedding-3-large excels at semantic similarity, text classification, clustering, and information retrieval. Its high-dimensional output allows fine-grained distinction between similar texts. It is a popular choice for building vector databases for RAG, where retrieval quality depends on embedding accuracy. The model also performs well on natural language inference and duplicate detection. However, it is not designed for generative tasks like text completion or dialogue—use GPT-4 or other language models for those.
The model can output embeddings with dimensions between 256 and 3072. The dimension is set via the `dimensions` parameter in the API request. Using a lower dimension reduces storage and downstream computation but may lose some semantic fidelity. The default dimension is 3072, which provides the highest discriminative power. There is no supported dimension outside this range. For most retrieval tasks, a dimension of 1024 to 2048 is a good balance between accuracy and cost.
If your application is latency-sensitive or you are embedding billions of texts, the $0.13 per 1M tokens cost can add up. Consider text-embedding-3-small ($0.02/M tokens) or open-source models like BERT-based embeddings for lower budgets. text-embedding-3-large is best when retrieval accuracy is paramount, such as in legal, medical, or scientific search, where a missed relevant document has large consequences.
OpenAI does not currently offer fine-tuning for the text-embedding-3 series. The model is used as a fixed encoder. To adapt it to a specific domain, you can employ retrieval augmentation strategies, such as adding domain-specific passages to your vector database. Alternatively, you can use the embeddings as features for a downstream classifier that is trained on your labeled data. This workflow is common in enterprise settings.
text-embedding-3-large achieves state-of-the-art results on the Massive Text Embedding Benchmark (MTEB) across tasks like clustering, classification, and reranking. While exact scores are not provided here, the model consistently ranks in the top tiers among publicly available embedding models. Its 3072-dimension version offers the highest accuracy, while lower dimensions trade off a small performance drop for reduced storage and compute. It outperforms its predecessor, text-embedding-ada-002, on most tasks.
Latency depends on input token count and model load. For a single short text (under 100 tokens), the model typically responds in under 200ms via OrcaRouter. Longer texts (8000 tokens) may take 1-2 seconds. Concurrency and batch size affect throughput—batched requests (multiple texts in one API call) can achieve higher throughput. OrcaRouter does not add overhead beyond the provider’s response time.
The model is not designed for multilingual support beyond English (though it handles some other languages, performance is lower). It also lacks built-in instruction following—it is strictly an encoder. The 8192 token limit means extremely long documents must be chunked. Additionally, embeddings may encode demographic biases present in training data, so downstream applications should be tested for fairness. Finally, it does not provide explainability for its similarity judgments.
text-embedding-3-large significantly outperforms the older ada-002 model on the MTEB benchmark, especially on tasks requiring fine-grained distinction. The newer model also introduces the `dimensions` parameter, allowing reduced vector size without retraining. Pricing is slightly higher ($0.13 vs $0.10 per 1M tokens for ada-002), but the improvement in accuracy often justifies the cost for high-stakes retrieval scenarios. For simple use cases, ada-002 remains a viable lower-cost alternative.
Pricing is $0.13 per 1 million input tokens, billed at provider rate with zero markup. Output tokens are also $0.13 per 1M tokens, though for embedding models output tokens are negligible since the model returns a vector. Input tokens include the text you send. There are no additional fees for using OrcaRouter’s API. This makes the total cost exactly what OpenAI charges, with no hidden charges or rate limit upcharges.
The $0.13 per 1M token rate is the standard provider price. OrcaRouter does not offer discounts on top of provider pricing. However, using smaller output dimensions (e.g., 1024) does not affect token counts—you pay per input token regardless of dimension. For very high-volume users, OpenAI may offer committed use discounts through custom agreements, which you can take advantage of independently.
OrcaRouter does not cache embedding responses. Each request is forwarded to the provider in real time and billed accordingly. If you repeatedly embed identical texts, you will be charged each time. To save costs, implement your own caching layer on the client side, storing embeddings for frequent queries. This is especially effective for static datasets like product descriptions or FAQ content.
OrcaRouter passes requests to the provider without artificial throttling, but the provider enforces its own rate limits. For text-embedding-3-large, typical limits are around 3000–5000 requests per minute for standard tier. You may increase limits by contacting OpenAI directly. OrcaRouter automatically retries on 429 errors, but excessive retries could incur additional cost. Monitor your usage to stay within limits.
Send a POST request to https://api.orcarouter.ai/v1/embeddings with the model parameter set to "openai/text-embedding-3-large". Include an input string or array of strings. Optionally set the `dimensions` parameter to a value between 256 and 3072. You can provide a user API key in the Authorization header (Bearer token). The response follows the same structure as OpenAI’s Embeddings API, containing an object list with embeddings and usage token counts.
The primary parameters are `model` (required: "openai/text-embedding-3-large"), `input` (a string or array of strings, up to 8192 tokens each), and `dimensions` (integer, optional, default 3072). OrcaRouter also supports the `user` parameter for tracking usage per end user. Other OpenAI Embeddings API parameters like `encoding_format` (float or base64) are supported. Refer to OpenAI’s documentation for the full set.
Change the base URL from https://api.openai.com/v1 to https://api.orcarouter.ai/v1 and update the model ID from "text-embedding-3-large" to "openai/text-embedding-3-large". Your existing code using the OpenAI Python client or HTTP library should work without other modifications. OrcaRouter’s API is fully compatible, so no changes to request body format are needed. Ensure you have an OrcaRouter API key.
Yes. Pass an array of strings as the `input` parameter. The API will return an array of embeddings in the same order. This is more efficient than sending individual requests due to lower overhead. For optimal throughput, batch texts of similar length to reduce idle time. The model supports up to 2048 strings per batch (check provider limits) and total input tokens across the batch must not exceed 2048000 tokens per minute.
The small variant uses only 512 dimensions and costs $0.02 per 1M tokens—about 6.5× cheaper. It is faster and more storage-efficient but sacrifices accuracy, especially on fine-grained semantic tasks. For simple clustering or search on topic-level similarity, the small model may suffice. text-embedding-3-large is recommended for high-stakes retrieval where recall matters most.
all-MiniLM-L6-v2 is a free, locally hosted model with 384 dimensions and high speed. It performs well on many tasks but falls short of text-embedding-3-large on complex benchmarks like MTEB. The trade-off is cost vs. quality: open-source models have zero per-token cost but require compute hardware. text-embedding-3-large offers superior accuracy while the $0.13/M tokens expense may be justified for production systems with retrieval quality as a priority.
Cohere’s embed-v3 models also support variable dimensions and multilingual capabilities. They are comparable on English benchmarks but may handle non-English texts better. Pricing is similar (roughly $0.10–0.15 per 1M tokens). The choice often depends on ecosystem preference and specific multilingual requirements. text-embedding-3-large has a larger context window (8192 vs 512 for Cohere) and is better integrated with OpenAI tools.
Consider alternatives if your use case requires multilingual support beyond English, needs on-premise deployment for data privacy, or demands extremely low latency at high throughput. For tasks like text generation, use GPT-4. For image-text embeddings, use CLIP or multimodal models. text-embedding-3-large is a general-purpose English encoder; if your domain is highly specialized, explore fine-tuned open-source models.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1dimensionsencoding_format| Input / 1M tokens | $0.130 |
|---|---|
| Output / 1M tokens | $0.130 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/openai/text-embedding-3-largeOpen @misc{orcarouter_text_embedding_3_large,
title = {openai/text-embedding-3-large API},
author = {openai},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/openai/text-embedding-3-large}
}openai. (n.d.). openai/text-embedding-3-large API. OrcaRouter. https://www.orcarouter.ai/models/openai/text-embedding-3-large