API gratuita de embeddings
Una API de embeddings convierte texto en vectores para la búsqueda, RAG y la agrupación. Varios proveedores dan embeddings gratis. FreeLLMAPI reúne 41 modelos de embeddings gratuitos detrás de un solo endpoint /v1/embeddings. Esta guía muestra los modelos, sus límites y código que funciona.
El código, los nombres de los modelos y las etiquetas del catálogo en vivo se muestran en inglés.
Cómo funcionan los embeddings gratuitos en FreeLLMAPI
El endpoint /v1/embeddings usa el formato de solicitud de OpenAI. Cualquier SDK de OpenAI puede llamarlo. Usted envía texto y recibe un vector por cada cadena de entrada.
Los embeddings usan una regla de conmutación distinta a la del chat. Las solicitudes de chat pueden pasar a otro modelo. Las solicitudes de embeddings nunca pasan a otro modelo. Los vectores de dos modelos no son compatibles, así que un cambio silencioso de modelo dañaría su almacén de vectores.
- Familia: FreeLLMAPI agrupa los proveedores por familia. Una familia es una identidad de modelo con un solo tamaño de vector, por ejemplo
bge-m3con 1024 dimensiones. - Conmutación: cuando un proveedor de una familia alcanza su límite, el enrutador prueba el siguiente proveedor que sirve la misma familia.
- Predeterminado:
model: "auto"usa la familia predeterminada. Usted configura la familia predeterminada en la página Models, Embeddings del panel.
Modelos de embeddings gratuitos hoy
La tabla enumera todos los modelos de embeddings gratuitos del catálogo de FreeLLMAPI. Los datos provienen del catálogo en vivo. "Max input" es el número máximo de tokens para una cadena de entrada. "Free limit" es la cuota gratuita que publica el proveedor.
| Modelo | Proveedor | Dimensiones | Entrada máx. | Límite gratuito |
|---|---|---|---|---|
Gemini Embeddinggemini-embedding-001 | Google AI Studio | 3072 | 2048 | 100 rpm · 1K req/day |
Nemotron Embed VL 1Bnvidia/llama-nemotron-embed-vl-1b-v2 | NVIDIA NIM | 2048 | 8192 | ~40 rpm |
Nemotron 3 Embed 1B (OR free)nvidia/nemotron-3-embed-1b:free | OpenRouter | 2048 | 32768 | 20 rpm · shared free daily cap |
SEA-LION E5 Embedding 600Maisingapore/SEA-LION-E5-Embedding-600M | SEA-LION | 1024 | 8192 | free · 10 rpm |
SEA-LION ModernBERT Embedding 300Maisingapore/SEA-LION-ModernBERT-Embedding-300M | SEA-LION | 1024 | 8192 | free · 10 rpm |
SEA-LION ModernBERT Embedding 600Maisingapore/SEA-LION-ModernBERT-Embedding-600M | SEA-LION | 1024 | 8192 | free · 10 rpm |
BGE-M3@cf/baai/bge-m3 | Cloudflare Workers AI | 1024 | 8192 | 10K neurons/day (shared) |
EmbeddingGemma 300M@cf/google/embeddinggemma-300m | Cloudflare Workers AI | 768 | 2048 | 10K neurons/day (shared) |
Qwen3 Embedding 0.6B@cf/qwen/qwen3-embedding-0.6b | Cloudflare Workers AI | 1024 | 8192 | 10K neurons/day (shared) |
Cohere Embed v4embed-v4.0 | Cohere | 1536 | 128000 | 1K calls/mo (shared w/ chat) |
Gemini Embedding 2gemini-embedding-2 | Google AI Studio | 3072 | 8192 | free-tier rate limited |
Nemotron 3 Embed 1Bnvidia/nemotron-3-embed-1b | NVIDIA NIM | 2048 | 4096 | ~40 rpm |
PLaMo Embedding 1B (CF)@cf/pfnet/plamo-embedding-1b | Cloudflare Workers AI | 2048 | 4096 | 10K neurons/day (shared) |
BGE Small EN v1.5 (CF)@cf/baai/bge-small-en-v1.5 | Cloudflare Workers AI | 384 | 512 | 10K neurons/day (shared) |
BGE Base EN v1.5 (CF)@cf/baai/bge-base-en-v1.5 | Cloudflare Workers AI | 768 | 512 | 10K neurons/day (shared) |
BGE Large EN v1.5 (CF)@cf/baai/bge-large-en-v1.5 | Cloudflare Workers AI | 1024 | 512 | 10K neurons/day (shared) |
Mistral Embedmistral-embed | Mistral | 1024 | 8192 | free mode · monthly cap (shared) |
Codestral Embedcodestral-embed | Mistral | 1536 | 8192 | free mode · monthly cap (shared) |
Llama Text Embed v2 (Pinecone)llama-text-embed-v2 | Pinecone | 1024 | 2048 | 5M tokens/mo per model |
Multilingual E5 Large (Pinecone)multilingual-e5-large | Pinecone | 1024 | 507 | 5M tokens/mo per model |
Nemotron 3 Embed 1B (Speka)nvidia/nemotron-3-embed-1b | Speka | 2048 | 8192 | $1/month shared across Speka models |
OpenAI: Text Embedding 3 Small (ElectronHub)text-embedding-3-small | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
OpenAI: Text Embedding 3 Large (ElectronHub)text-embedding-3-large | ElectronHub | 3072 | 8192 | $0.25/week shared free credits |
Nemotron 3 Embed 8B (Inferbase)nvidia-nemotron-3-embed-8b | Inferbase | 4096 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 0.6B (Inferbase)qwen3-embedding-0-6b | Inferbase | 1024 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 4B (Inferbase)qwen3-embedding-4b | Inferbase | 2560 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 8B (Inferbase)qwen3-embedding-8b | Inferbase | 4096 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
LFM2.5 Embedding 350M (LLMTR)liquid/lfm-2.5-embedding-350m-free | LLMTR | 1024 | 512 | Ongoing zero-price route; provider terms apply |
BGE-M3 (SEA-LION)BAAI/bge-m3 | SEA-LION | 1024 | 8192 | free · 10 rpm |
Cohere Embed English v3embed-english-v3.0 | Cohere | 1024 | 512 | 1K calls/mo (shared w/ chat) |
Qwen3 Embedding 8B (OVH)Qwen3-Embedding-8B | OVH AI Endpoints | 4096 | 32768 | free · anonymous 2 req/min per IP |
BGE-M3 (OVH)bge-m3 | OVH AI Endpoints | 1024 | 8192 | free · anonymous 2 req/min per IP |
BGE Multilingual Gemma2 (OVH)bge-multilingual-gemma2 | OVH AI Endpoints | 3584 | 8192 | free · anonymous 2 req/min per IP |
Mistral: Codestral Embed (ElectronHub)codestral-embed | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
Mistral: Mistral Embed (ElectronHub)mistral-embed | ElectronHub | 1024 | 8192 | $0.25/week shared free credits |
Google: Gemini Embedding 2 (ElectronHub)gemini-embedding-2 | ElectronHub | 3072 | 8192 | $0.25/week shared free credits |
Google: Gemini Embedding 001 (ElectronHub)gemini-embedding-001 | ElectronHub | 3072 | 2048 | $0.25/week shared free credits |
OpenAI: Text Embedding Ada 002 (ElectronHub)text-embedding-ada-002 | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
Cohere Embed English Light v3embed-english-light-v3.0 | Cohere | 384 | 512 | 1K calls/mo (shared w/ chat) |
Cohere Embed Multilingual v3embed-multilingual-v3.0 | Cohere | 1024 | 512 | 1K calls/mo (shared w/ chat) |
Cohere Embed Multilingual Light v3embed-multilingual-light-v3.0 | Cohere | 384 | 512 | 1K calls/mo (shared w/ chat) |
Datos en vivo del catálogo de FreeLLMAPI (versión 2026.11.19, revisado 2026-11-19). Los límites gratuitos cambian con frecuencia. El catálogo se revisa todos los días.
Algunos proveedores comparten una sola cuota entre el chat y los embeddings. Por ejemplo, una clave de prueba de Cohere permite 1,000 llamadas a la API cada mes para todos los endpoints juntos. Cloudflare Workers AI da 10,000 neuronas cada día, compartidas por todos los modelos de Workers AI de la cuenta.
Paso 1: Instale FreeLLMAPI y agregue claves
FreeLLMAPI es de código abierto. Se ejecuta en su computadora con Docker. Sus claves de proveedores se quedan en su computadora.
Instalar (macOS o Linux)
curl -fsSL https://freellmapi.co/install.sh | bashAbra el panel en http://localhost:3001. Agregue sus claves de proveedores en la página Keys. Para los embeddings, una clave de Google AI Studio y una clave de Cloudflare son un buen comienzo. Copie su clave unificada desde la misma página.
Paso 2: Llame al endpoint de embeddings
Envíe una lista de cadenas para obtener varios vectores en una sola solicitud. Use el mismo valor de model para sus documentos y para sus consultas de búsqueda.
curl
curl http://localhost:3001/v1/embeddings \
-H "Authorization: Bearer <unified-key>" \
-H "Content-Type: application/json" \
-d '{"model": "bge-m3", "input": ["the quick brown fox", "a fast brown fox"]}'Python: generar embeddings y comparar dos textos
import math
from openai import OpenAI
client = OpenAI(base_url="http://localhost:3001/v1", api_key="<unified-key>")
resp = client.embeddings.create(
model="bge-m3", # a family name, "auto", or a provider model id
input=["How do I reset my password?", "Steps to change a forgotten password"],
)
a, b = resp.data[0].embedding, resp.data[1].embedding
print(len(resp.data), "vectors of", len(a), "dimensions")
dot = sum(x * y for x, y in zip(a, b))
norm = math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b))
print("cosine similarity:", round(dot / norm, 3))El campo model acepta tres formas: auto, un nombre de familia como bge-m3, o un ID de modelo del proveedor como @cf/baai/bge-m3. Un ID de modelo del proveedor se resuelve a su familia, así que la conmutación sigue dentro de esa familia.
Qué modelo de embeddings gratuito elegir
Elija el modelo una vez para cada almacén de vectores. Si cambia el modelo después, debe generar de nuevo los embeddings de todos los documentos.
| Necesidad | Familia del modelo | Motivo |
|---|---|---|
| Texto corto en inglés o multilingüe, muchos proveedores | bge-m3 | 1024 dimensiones, 8,192 tokens de entrada. Varios proveedores gratuitos lo sirven, así que la conmutación tiene más opciones. |
| Recuperación de alta calidad con una clave de Google | gemini-embedding-001 | 3072 dimensiones. El límite de entrada es de 2,048 tokens, así que divida los documentos largos en fragmentos. |
| Documentos largos en un solo vector | embed-v4.0 (Cohere) | Ventana de entrada grande. La clave de prueba permite solo 1,000 llamadas cada mes, compartidas con el chat. |
| Vectores pequeños y búsqueda rápida | bge-small-en-v1.5 | 384 dimensiones. Solo inglés, y el límite de entrada es de 512 tokens. |
| Búsqueda de código | codestral-embed | Entrenado para código. Usa la cuota del modo gratuito de Mistral. |
Los vectores grandes cuestan más almacenamiento y memoria en la base de datos vectorial. Un vector de 3072 dimensiones es tres veces más grande que uno de 1024 dimensiones. En la mayoría de los proyectos RAG con menos de un millón de fragmentos, de 768 a 1024 dimensiones dan buenos resultados.
Límites y errores frecuentes
- Límites de entrada: el texto por encima del valor "Max input" puede cortarse o rechazarse. Divida los documentos en fragmentos de 300 a 800 tokens antes de generar sus embeddings.
- Una familia por almacén: no mezcle vectores de dos familias en un mismo índice. Las puntuaciones de similitud no tienen sentido entre modelos.
- Normalización: Google indica que usted debe normalizar los vectores de
gemini-embedding-001con menos de 3072 dimensiones. Normalice todos los vectores antes de usar el producto punto como puntuación. - Límites de uso: los niveles gratuitos cuentan las solicitudes por minuto o por día. Envíe lotes de cadenas en una sola solicitud, no una solicitud por cada cadena.
- Niveles anónimos: OVH AI Endpoints permite 2 solicitudes por minuto por cada dirección IP y modelo sin clave. Úselo como respaldo, no para indexar en masa.
Solución de problemas
| Problema | Causa | Solución |
|---|---|---|
| Error 429 durante la indexación en masa | Se alcanzó el límite del proveedor para la familia | Agregue una segunda clave de proveedor para la misma familia, o envíe menos solicitudes por minuto |
| Los resultados de búsqueda son incorrectos después de un cambio | Los documentos y las consultas usan familias distintas | Use un solo valor de model para ambos. Genere de nuevo los embeddings de los documentos si lo cambió |
| La longitud del vector no es la que espera | auto usa la familia predeterminada | Configure un nombre de familia explícito, o revise el valor predeterminado en Models, Embeddings |
| Los textos largos dan coincidencias deficientes | El texto es más largo que el límite de entrada | Divida el texto en fragmentos más pequeños |
| Error 401 | La clave unificada es incorrecta o falta | Copie de nuevo la clave unificada desde la página Keys |
Preguntas frecuentes
¿Existe una API gratuita de embeddings?
Sí. Google AI Studio, Cloudflare Workers AI, Cohere, NVIDIA, Mistral, OVH y otros ofrecen modelos de embeddings gratuitos con límites de uso. FreeLLMAPI reúne 41 de ellos detrás de un solo endpoint compatible con OpenAI.
¿Puedo usar el SDK de OpenAI para embeddings gratuitos?
Sí. Configure la base URL como http://localhost:3001/v1 y use su clave unificada. Después, llame a client.embeddings.create con un nombre de familia como bge-m3.
¿Por qué FreeLLMAPI no cambia a otro modelo de embeddings cuando falla?
Los vectores de modelos distintos no son compatibles. Un cambio silencioso de modelo rompería la búsqueda por similitud. El enrutador solo cambia entre proveedores que sirven la misma familia de modelos.
¿Cuál es el mejor modelo de embeddings gratuito para RAG?
Para la mayoría de los proyectos, bge-m3 es una buena opción predeterminada. Tiene 1024 dimensiones, un límite de entrada de 8,192 tokens y varios proveedores gratuitos. Use gemini-embedding-001 si quiere 3072 dimensiones y tiene una clave de Google.
¿Cuántas dimensiones deben tener mis embeddings?
Use de 768 a 1024 dimensiones para la mayoría de los trabajos de búsqueda y RAG. Los vectores más grandes usan más almacenamiento y memoria. Elija el tamaño una vez, porque un cambio obliga a generar de nuevo los embeddings de todos los documentos.
Guías relacionadas
- API LLM gratuita para RAG
- API LLM gratuita para LangChain
- API de LLM gratuita en Python
- free cohere api
- Límites de uso de API LLM gratuitas
Fuentes
- FreeLLMAPI docs: Embeddings (revisado 20 November 2026)
- Google AI Studio docs: Embeddings (revisado 20 November 2026)
- Cloudflare Workers AI pricing (revisado 20 November 2026)
- Cohere docs: API keys and rate limits (revisado 20 November 2026)
- OVHcloud AI Endpoints capabilities (revisado 20 November 2026)