Inicio / Guías / API de LLM gratuita en Python

API de LLM gratuita en Python

El paquete oficial de Python openai funciona con cualquier API compatible con OpenAI. Solo cambia la base URL y la clave. Esta guía usa FreeLLMAPI, que reúne 45 niveles gratuitos de proveedores detrás de una sola clave y pasa al siguiente proveedor cuando un límite detiene una solicitud. Cada ejemplo de abajo está completo y se ejecuta tal como está.

El código, los nombres de los modelos y las etiquetas del catálogo en vivo se muestran en inglés.

Configuración

Instale FreeLLMAPI. Se ejecuta en Docker. Abra el panel en http://localhost:3001, agregue claves gratuitas de dos o más proveedores en la página Keys y copie la clave unificada. Después, instale el paquete de Python.

Su código Python usa solo la clave unificada. Las claves de los proveedores se quedan en FreeLLMAPI, cifradas en su base de datos. Si cambia o agrega una clave de proveedor, no necesita cambiar su código.

Instalar

curl -fsSL https://freellmapi.co/install.sh | bash

python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>

client.py

import os
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],
    max_retries=3,   # the SDK retries 429, 408, 409 and 5xx errors
    timeout=60,
)

resp = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)

El modelo auto sigue la cadena de respaldo de su panel. También puede usar auto:fast, auto:smart o auto:reliable, un perfil como auto:coding, o un ID de modelo fijo.

Streaming y encabezados de respuesta

Reciba la respuesta en streaming

from client import client

stream = client.chat.completions.create(
    model="auto:fast",
    messages=[{"role": "user", "content": "Write a haiku about Python."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)
print()

Cada respuesta tiene un encabezado X-Routed-Via con el proveedor y el modelo que respondieron. Para leer los encabezados con el SDK, use with_raw_response y llame a parse() para obtener el objeto normal.

Lea los encabezados de enrutamiento

from client import client

raw = client.chat.completions.with_raw_response.create(
    model="auto",
    messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)

Llamadas a herramientas

Envíe tools con el formato de OpenAI. El enrutador los pasa a los proveedores compatibles con OpenAI y los traduce para Gemini. La respuesta vuelve en el mismo formato para todos los proveedores.

Una llamada a herramienta y la respuesta final

import json
from client import client

tools = [{
    "type": "function",
    "function": {
        "name": "get_exchange_rate",
        "description": "Get the exchange rate between two currencies.",
        "parameters": {
            "type": "object",
            "properties": {
                "base": {"type": "string"},
                "quote": {"type": "string"},
            },
            "required": ["base", "quote"],
        },
    },
}]

messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"base": args["base"], "quote": args["quote"], "rate": 0.92}  # your real lookup
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Algunos proveedores devuelven una llamada a herramienta como texto simple. FreeLLMAPI convierte estas respuestas en tool_calls reales, así que su código lee un solo formato. Revise siempre msg.tool_calls antes de leer msg.content, porque un modelo también puede responder sin usar una herramienta.

Use un modelo con llamadas a herramientas. Estos modelos gratuitos admiten herramientas y tienen hoy la velocidad medida más alta:

Modelos gratuitos rápidos con llamadas a herramientas
ModeloGratis enContextoLímites gratuitos (mejor oferta)HerramientasVisión
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 solicitudes/min
250 solicitudes/día
70,000 tokens/min
~6M
SíSí
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 solicitudes/min
50 solicitudes/día
50 req/day account-wide (1,000 after a $10 purchase)
SíNo
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 más131K30 solicitudes/min
1,000 solicitudes/día
8,000 tokens/min
200,000 tokens/día
~6M
SíNo
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 más131K30 solicitudes/min
1,000 solicitudes/día
8,000 tokens/min
200,000 tokens/día
~6M
SíNo
GPT-OSS Safeguard 20BGroq131K30 solicitudes/min
1,000 solicitudes/día
8,000 tokens/min
200,000 tokens/día
~6M
SíNo
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 solicitudes/min
20 solicitudes/día
250,000 tokens/min
~3M
SíSí
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditSíSí
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 solicitudes/min
5,000 solicitudes/día
500,000 tokens/día
500K tokens/day · 5,000 req/day
SíSí
Nemotron 3.5 Lightning 30BRequesty1M200 solicitudes/día
200 rpd
SíNo
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 solicitudes/min
20 solicitudes/día
250,000 tokens/min
~3M
SíSí

Se muestran 10 de 146 modelos gratuitos que coinciden. Ver todos los modelos.

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.

Lotes asíncronos dentro de los límites gratuitos

AsyncOpenAI envía muchas solicitudes al mismo tiempo. Los niveles gratuitos limitan las solicitudes por minuto, así que limite la concurrencia con un semáforo. El ejemplo también reintenta cuando todos los proveedores llegan a su límite.

batch.py

import asyncio
import os

import openai
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],
    max_retries=2,
)
limit = asyncio.Semaphore(4)  # at most 4 requests at a time

async def summarize(text: str) -> str:
    async with limit:
        for attempt in range(5):
            try:
                resp = await client.chat.completions.create(
                    model="auto:fast",
                    messages=[
                        {"role": "system", "content": "Summarize in one sentence."},
                        {"role": "user", "content": text},
                    ],
                )
                return resp.choices[0].message.content
            except openai.RateLimitError as err:
                header = err.response.headers.get("retry-after", "")
                wait = int(header) if header.isdigit() else 2 ** attempt
                await asyncio.sleep(min(wait, 60))
        return "ERROR: rate limited"

async def main():
    docs = [f"Document {i}: Python is a programming language." for i in range(20)]
    results = await asyncio.gather(*(summarize(d) for d in docs))
    for r in results:
        print(r)
    await client.close()

asyncio.run(main())

El enrutador devuelve 429 solo cuando todas las claves de la cadena llegaron a su límite. La respuesta entonces tiene un encabezado Retry-After. Un valor pequeño de semáforo y más claves de proveedores dan los mejores resultados en lotes grandes.

Elija una cadena de modelo para cada tarea

La cadena de modelo indica al enrutador cómo elegir un modelo. Puede usar una cadena distinta en cada llamada. No necesita cambiar el panel.

TareaCadena de modeloMotivo
Respuestas de chat para usuariosautoSigue la cadena de respaldo que configuró en el panel
Clasificación, extracción, resúmenes brevesauto:fastOrdena los modelos habilitados por velocidad medida
Preguntas difíciles, revisión de código, planificaciónauto:smartOrdena los modelos habilitados por inteligencia
Trabajos programados que deben terminarauto:reliableOrdena los modelos habilitados por la tasa de éxito reciente
Una cadena separada para una aplicaciónauto:<profile>Usa una cadena de respaldo con nombre
Pruebas que deben poder repetirseUn ID de modelo fijoEl mismo modelo cada vez, pero se detiene en el límite de ese modelo

Para ver qué modelos pueden responder hoy con sus claves, pida la lista de modelos con un filtro. La lista completa también contiene modelos que todavía no tienen clave.

Liste los modelos que pueden responder ahora

import os
import httpx

r = httpx.get(
    "http://localhost:3001/v1/models",
    params={"execution_status": "ready"},
    headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
    timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
    print(m["id"])

Un modelo con el estado exhausted tiene claves, pero todas están en un límite ahora. El estado se borra cuando terminan los tiempos de espera. Un modelo con el estado needsKey no tiene una clave habilitada.

Para una conversación, envíe un encabezado X-Session-Id con extra_headers. FreeLLMAPI entonces mantiene esa conversación en un mismo modelo durante 30 minutos. Sin el encabezado, usa un hash del primer mensaje del usuario como clave de sesión.

Embeddings

Genere embeddings de texto

from client import client

resp = client.embeddings.create(
    model="bge-m3",  # one embedding family
    input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")

La conmutación de embeddings nunca cambia el modelo. Solo pasa entre proveedores que sirven la misma familia, así que sus vectores siguen siendo compatibles. El valor auto usa la familia predeterminada que configuró en el panel.

Envíe muchos textos en una sola lista input. Una solicitud con 32 textos usa una solicitud del límite gratuito, no 32. Mantenga cada texto por debajo del máximo de entrada de la familia. Guarde el nombre de la familia junto con sus vectores, para generar los embeddings de las consultas con la misma familia más adelante.

Errores y soluciones

ExcepciónCausaSolución
openai.AuthenticationErrorClave unificada incorrectaCopie la clave de nuevo desde la página Keys
openai.APIConnectionErrorFreeLLMAPI no se está ejecutando, o el puerto es incorrectoAbra http://localhost:3001 en el navegador
openai.NotFoundErrorLa base URL no tiene /v1Use http://localhost:3001/v1
openai.RateLimitErrorTodas las claves de la cadena llegaron a su límiteAgregue proveedores, reduzca la concurrencia y espere el valor de Retry-After
openai.BadRequestError con auto:nameEl nombre del perfil no existeRevise el nombre del perfil en el panel
openai.UnprocessableEntityError (422) con imágenesNo hay ningún modelo de visión en su cadenaHabilite un modelo de visión en la cadena de respaldo

Los niveles gratuitos no tienen SLA. La latencia cambia durante el día. Los modelos más sólidos alcanzan primero sus límites diarios, y muchos límites se reinician a medianoche UTC. No use una pasarela gratuita para un servicio que debe responder en un tiempo fijo.

Use cada uno de estos modelos con una sola clave. FreeLLMAPI es un enrutador de código abierto y autoalojado. Reúne todos estos niveles gratuitos detrás de un único endpoint compatible con OpenAI y cambia de proveedor cuando uno alcanza su límite. Explore el catálogo o ir en vivo.

Preguntas frecuentes

¿Existe una API de LLM gratuita para Python?

Sí. Muchos proveedores tienen niveles gratuitos que funcionan con el paquete openai de Python. FreeLLMAPI los combina detrás de una sola base URL y una sola clave, con conmutación entre proveedores.

¿Cómo uso la biblioteca openai de Python con una base URL distinta?

Pase base_url a OpenAI() o AsyncOpenAI(), por ejemplo base_url="http://localhost:3001/v1". Pase la clave de su pasarela como api_key.

¿Cómo manejo los errores de límite de uso en Python?

Configure max_retries en el cliente. Capture openai.RateLimitError, lea el encabezado Retry-After y espere. Limite la concurrencia con un semáforo de asyncio.

¿El streaming funciona con APIs de LLM gratuitas en Python?

Sí. Pase stream=True y lea chunk.choices[0].delta.content. FreeLLMAPI envía el streaming en formato OpenAI para todos los proveedores.

¿Puedo usar Python asíncrono con una API de LLM gratuita?

Sí. Use AsyncOpenAI con la misma base_url y clave. Mantenga pequeño el número de solicitudes en paralelo, porque los niveles gratuitos limitan las solicitudes por minuto.

Guías relacionadas

Fuentes

Todas las guías · Ver todos los modelos gratuitos