Get My API Key
Get My API Key

Powered by OpenAI

Text Embedding 3 Large

  • Text Generation

Text Embedding 3 Large is OpenAI’s high‑capacity embedding model optimized for semantic search, retrieval, and clustering tasks. It provides high‑quality vector representations of text with strong performance across diverse domains.

Start Using API

Providers Comparison

Speed

Output tokens per second · Higher is better

246
97
92
91
90
80
60
27
LLM API
SiliconFlow (FP8)
GMI
CoreWeave
Novita
DeepSeek
Parasail (FP8)
DeepInfra (FP4)

End-to-End Response Time

Seconds · Lower is better

65.1
8.1
19.8
20.4
20.9
23.1
24.6
30.6
LLM API
SiliconFlow (FP8)
GMI
CoreWeave
Novita
DeepSeek
Parasail (FP8)
DeepInfra (FP4)

Price

USD per 1M tokens (blended) · Lower is better

65.1
8.1
19.8
20.4
20.9
23.1
24.6
30.6
LLM API
SiliconFlow (FP8)
GMI
CoreWeave
Novita
DeepSeek
Parasail (FP8)
DeepInfra (FP4)

About the model

What is Text Embedding 3 Large?

Text Embedding 3 Large is an OpenAI model that converts text into high‑dimensional vector embeddings for downstream machine learning and retrieval applications. It is primarily used for tasks such as semantic search, reranking, and building retrieval‑augmented generation (RAG) systems over large document collections. It is also used for similarity search, clustering, classification features, and other applications that rely on dense vector representations of text. It is part of OpenAI’s text-embedding-3 family, succeeding earlier OpenAI embedding models like the text-embedding-ada family.

Model capabilities

5 Core Capabilities

  • High-Dimension Embeddings

    Generates high-quality vector representations of text optimized for semantic tasks like clustering, retrieval, and similarity search.

  • Semantic Search

    Enables retrieval of conceptually related documents by comparing embedding vectors instead of relying purely on keyword matching.

  • Text Clustering

    Supports grouping related texts by embedding them into a shared vector space for downstream clustering and topic analysis.

  • Multilingual Semantics

    Produces embeddings that capture meaning across multiple languages, enabling cross-lingual similarity and retrieval workflows.

  • Document Classification

    Provides embeddings usable as features for training classifiers to categorize documents by topic, intent, or other labels.

Use cases

6 Most Valuable Use Cases

  • Semantic Text Search
  • Document Clustering
  • Topic Tagging Support
  • Product Recommendation Matching
  • Cross-Lingual Similarity
  • Legal Case Monitoring

Transparent pricing

Cost Comparison

LLM API offers the lowest-cost, highest-capacity embeddings versus comparable Text Embedding 3 Large tiers.

Provider Region Latency Throughput Uptime Input ($/1M) Output ($/1M) Context
LLM API BEST Global ~110ms ~65K tokens/s 99.99% ~$0.02 $0.00 ~1M tokens
OpenAI Global ~180ms ~40K tokens/s 99.9% $0.13 $0.00 ~8192 tokens
Azure OpenAI US East ~190ms ~35K tokens/s 99.9% ~$0.14 $0.00 ~8192 tokens
Anthropic US West ~200ms ~30K tokens/s 99.9% ~$0.15 $0.00 ~200K tokens

Performance benchmarks

Technical Specifications

Metric Text Embedding 3 Large (OpenAI) text-embedding-3-large (OpenAI) text-embedding-ada-002 (OpenAI)
Dimensions 3072 3072 1536
Max Input Tokens 8192 8192 8192
Price per 1M Tokens $0.13 $0.13 $0.10
Avg Latency ~220ms ~250ms ~260ms
Throughput ~1,200 tps ~1,000 tps ~950 tps
Uptime 99.9% 99.9% 99.9%

30-day usage via LLM API

9.8T
Embedding tokens processed (30 days)
120M
API requests served (30 days)
480K
Active developer accounts (30 days)
99.98%
Avg API uptime (30 days)
Start Using API

Architecture & Integration

Why Build on LLM.API?

One unified API. Every major model. Built-in reliability, cost control, and observability.

  • Unified AI Routing

    Define policies once and let LLM.API automatically route each call to the best model across providers, balancing latency, accuracy, and availability with no client changes.

    One endpoint, every model.

  • Cost-Aware Orchestration

    Set hard budgets and price tiers, then let LLM.API choose cheaper models by default and escalate only when needed, cutting spend without touching application code.

    Spend less per token.

  • Automatic Failover Guardrails

    When a provider is slow, degraded, or down, LLM.API retries and fails over to healthy models, preserving SLAs and user experience without manual incident playbooks.

    Resilience by default.

  • End-to-End Observability

    Get centralized traces, logs, and metrics for every request across all models and providers, making debugging, performance tuning, and cost attribution straightforward.

    See every token.

  • Task-Level Abstractions

    Express work as tasks—chat, generation, extraction, tools—and let LLM.API pick the right model and configuration, so you ship features instead of juggling parameters.

    Code to tasks, not models.

  • High-Throughput Batch APIs

    Submit massive job batches through a single endpoint with built-in concurrency control, retries, and progress tracking, maximizing throughput while protecting upstream systems.

    Scale jobs, not scripts.

Decision guide

When to Use — When NOT to Use

Use it if...

  • You need high-quality semantic embeddings for search, clustering, or retrieval over large corpora.
  • You need strong multilingual text understanding across many languages in a single model.
  • You need embeddings well-optimized for retrieval-augmented generation with OpenAI chat models.
  • Your use case involves semantic deduplication, near-duplicate detection, or content similarity scoring.
  • Your use case involves recommendation or ranking systems based on textual semantic similarity.
  • You need compact numeric representations of text for downstream ML models or classifiers.

Avoid if...

  • You need a model that directly generates text, code, or natural language responses.
  • Your workload requires image, audio, or multimodal embeddings rather than pure text embeddings.
  • You need on-device or fully offline embeddings without relying on external APIs.
  • Your workload requires real-time per-token streaming responses instead of whole-vector outputs.
  • You need controllable text generation, reasoning, or tool use rather than representation learning.
  • Your workload requires extremely small embeddings tailored for ultra-low-latency edge deployments.

FAQ

Frequently Asked Questions

  • What is Text Embedding 3 Large?

    Text Embedding 3 Large is an OpenAI text-only embedding model optimized for high-quality, dense vector representations of longer texts.

  • What is Text Embedding 3 Large best suited for?

    It is best for high-accuracy semantic search, retrieval-augmented generation, clustering, recommendations, and other tasks needing rich semantic text similarity.

  • What context length does Text Embedding 3 Large support?

    Text Embedding 3 Large supports input sequences up to 8,191 tokens in length.

  • What modalities does Text Embedding 3 Large support?

    Text Embedding 3 Large supports text input only and outputs numerical embedding vectors.

  • How does the pricing of Text Embedding 3 Large work on LLM.API?

    Pricing is typically per 1,000 input tokens, with LLM.API applying OpenAI’s base rates plus any LLM.API-specific fees or discounts.

  • How fast is Text Embedding 3 Large in terms of latency?

    Embedding models are generally low-latency, and Text Embedding 3 Large is suitable for real-time or near–real-time semantic search workloads.

  • How do I call Text Embedding 3 Large through LLM.API?

    Use LLM.API’s embeddings endpoint, specify provider "openai" and model "text-embedding-3-large," and pass your text inputs in the request body.

  • How does Text Embedding 3 Large compare to Text Embedding 3 Small?

    Text Embedding 3 Large offers higher embedding quality and accuracy, while Text Embedding 3 Small is cheaper and faster but slightly less accurate.

  • Does Text Embedding 3 Large support multilingual text?

    Yes, Text Embedding 3 Large supports multiple languages, making it suitable for cross-lingual semantic search and similarity tasks.

  • What are the main limitations of Text Embedding 3 Large?

    It cannot generate text or process images, may encode training-data biases, and its performance degrades if inputs exceed the token limit.

Compare

Competitive Models

Qwen3.5-122B-A10B

  • Text Generation

Qwen3.5-122B-A10B is a 122B-parameter open-weight Mixture-of-Experts vision-language model from Qwen that activates 10B parameters per token and supports a 262K-token context window. It is designed to…

Qwen3 VL 30B A3B Thinking

  • Text Generation

Qwen3 VL 30B A3B Thinking is a large multimodal Qwen model with around 30 billion parameters, designed for vision-language reasoning with extended “thinking” capabilities. It is…

Olmo 3 32B Think

  • Text Generation

Olmo 3 32B Think is a 32-billion-parameter open-weight reasoning model from the Allen Institute for AI, optimized for deep chain-of-thought reasoning and complex instruction following. It…

Start in 2 lines of code

Get My API Key