ES ▾

openaiapiproxy.comProxy de API de OpenAI en Python: configuración y ejemplos

Proxy de API de OpenAI en Python: configuración y ejemplos

Para un proyecto de proxy de API de OpenAI en Python, mantienes el paquete oficial de OpenAI y cambias dos argumentos del constructor: base_url y api_key. El resto de esta página cubre streaming, async, herramientas, reintentos y control del gasto.

Actualizado

Una terminal de vidrio con una cinta de luz fluyendo hacia un cubo, ilustrando código Python llamando a un proxy de API

Puntos clave

  • Instala openai, luego construye OpenAI(base_url=..., api_key=...) con el modelo configurado como uncensored.
  • Streaming, modo JSON y llamadas a funciones usan los parámetros estándar, y el modo async funciona de la misma manera.
  • Limita la concurrencia a 8 con un semáforo y deja que el SDK reintente las respuestas 429.
  • Lee X-Balance-USD de los encabezados de respuesta sin procesar para vigilar tu crédito desde el código.

Ejemplo mínimo funcional

Aquí tienes la configuración de proxy api de openai python más corta y útil. Asume Python 3.9 o superior, una clave de la página de clave de API, el paquete instalado con pip install openai y la clave exportada como UNCENSORED_API_KEY.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.openaiapiproxy.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Give me a one-line product tagline for a hiking app."}],
    temperature=0.8,
    max_tokens=60,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

El endpoint es compatible con OpenAI, pero es un servicio independiente. No es la API oficial de OpenAI ni de ningún otro proveedor, y aloja un único modelo, uncensored. Solo existen dos rutas: POST /v1/chat/completions y GET /v1/models, así que usa la interfaz de completación de chat del SDK.

Algunas notas sobre ese código. La clave proviene de una variable de entorno en lugar de un literal, por lo que nunca se guarda en el control de versiones. El objeto usage en la respuesta contiene los recuentos exactos de tokens en los que se basa la factura, lo cual es útil para registrar. Y max_tokens es opcional: si no lo incluyes, la finalización puede usar el resto de la ventana, lo cual está bien para historias pero es costoso para un bucle con un error.

Tokens de streaming a medida que llegan

El streaming usa eventos enviados por el servidor. Pasa stream=True e itera sobre los fragmentos. La última parte del flujo contiene el uso de tokens, así que protege los fragmentos sin opciones.

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
    stream=True,
)

usage = None
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        usage = chunk.usage
print()
if usage:
    print("tokens:", usage.prompt_tokens, usage.completion_tokens)

Un detalle operativo: una llamada de streaming ocupa una de tus ranuras de concurrencia hasta que termina el flujo. Si tu código sale del bucle antes, cierra el flujo (stream.close()) para liberar la ranura.

Una aplicación web suele envolver este bucle en un generador y reenviar cada pieza al navegador. Con FastAPI, eso significa devolver un StreamingResponse que genera las partes de texto. Mantén la clave en el servidor con ese diseño. El navegador habla con tu ruta, y tu ruta habla con la API, por lo que la clave nunca se expone al código del cliente.

Clientes asíncronos y concurrencia controlada

Una clave completa permite 8 peticiones a la vez y 300 por minuto. Una clave de prueba permite 2 y 60. Si lanzas 200 corutinas con asyncio.gather, recogerás errores 429 con el código concurrency. Un semáforo corrige eso antes de que ocurra.

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
gate = asyncio.Semaphore(8)

async def ask(prompt: str) -> str:
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a title for chapter {i} of a sea adventure." for i in range(1, 41)]
    results = await asyncio.gather(*(ask(p) for p in prompts))
    for t in results:
        print(t)

asyncio.run(main())

Usa 2 como tamaño del semáforo mientras estás con la clave de prueba. El SDK reintenta las respuestas 429 con retroceso por defecto, y max_retries aumenta el número de intentos. Para sobrecarga temporal, el servicio responde con 429 y Retry-After: 5, que el SDK respeta.

Un semáforo solo limita las peticiones en curso dentro de un proceso. Si ejecutas varios trabajadores, divide el límite entre ellos: con una clave completa, cuatro trabajadores deberían usar cada uno un semáforo de 2. El límite por minuto de 300 es compartido por todos, por lo que una cola con una tasa constante es mejor que un pico para trabajos grandes en segundo plano. El límite de cuerpo de 8 MB rara vez es un problema para chat, pero se aplica a cada petición.

Modo JSON y llamadas a funciones

Ambos funcionan a través de los parámetros normales. Para el modo JSON, establece response_format y pide JSON en el prompt.

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Return JSON with keys name, mood and hook."},
        {"role": "user", "content": "Invent a tavern keeper for a fantasy game."},
    ],
)
npc = json.loads(r.choices[0].message.content)
print(npc["name"])

Las llamadas a funciones necesitan un paso extra: ejecutas la función tú mismo y devuelves el resultado como un mensaje tool.

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides.",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a twenty-sided die for me."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    sides = json.loads(call.function.arguments)["sides"]
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": "14"})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

El valor devuelto para el dado aquí está codificado para brevedad. En código real, llama a tu función con sides y envía su resultado.

Dos detalles más sobre herramientas. Usa tool_choice cuando necesites forzar una función específica en lugar de dejar que el modelo decida. Y mantén las descripciones de las herramientas específicas: el modelo elige una función solo por su nombre y descripción, así que "Lanza un dado con el número de caras dado" funciona mejor que "dados". Si una respuesta contiene varias llamadas a funciones, ejecútalas todas y añade un mensaje tool por ID de llamada antes de pedir la respuesta final.

Errores, reintentos e historial de conversaciones

El SDK lanza excepciones tipadas, lo que hace que el manejo de errores sea breve. Un 429 lanza openai.RateLimitError, un fallo de red lanza openai.APIConnectionError, y otros estados no exitosos lanzan openai.APIStatusError. El SDK ya ha reintentado cuando ves el primero, por lo que lo que llega a tu código es una llamada que falló repetidamente.

import time
import openai
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=2)

def chat(messages, attempts=4):
    delay = 2.0
    for n in range(attempts):
        try:
            r = client.chat.completions.create(model="uncensored", messages=messages)
            return r.choices[0].message.content
        except openai.RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay *= 2
        except openai.APIConnectionError:
            time.sleep(delay)
            delay *= 2
    raise RuntimeError("gave up after repeated failures")

print(chat([{"role": "user", "content": "Name a color."}]))

El código lee Retry-After cuando el servicio lo envía, lo cual ocurre en sobrecarga temporal (el valor es 5 segundos). Cuando falta el encabezado, retrocede en su propio horario. Ten en cuenta que el bucle no captura todos los errores: una petición incorrecta no mejorará con un reintento, así que déjala propagarse.

El historial de conversaciones es la otra parte del estado. La API no lo almacena por ti, así que tu programa es dueño de la lista de mensajes. Una política simple que funciona bien: mantén el mensaje del sistema, mantén los últimos N intercambios, y cuando el total crezca más allá de un tamaño que elijas, pide al modelo que resuma la parte más antigua en un mensaje corto.

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def compact(history, keep=6):
    system, rest = history[0], history[1:]
    if len(rest) <= keep:
        return history
    old, recent = rest[:-keep], rest[-keep:]
    text = "\n".join(m["role"] + ": " + m["content"] for m in old)
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarize this conversation in 120 words:\n" + text}],
        max_tokens=250,
    )
    summary = {"role": "system", "content": "Earlier in this conversation: " + r.choices[0].message.content}
    return [system, summary] + recent

Los resúmenes también cuestan tokens, pero se pagan solos: una conversación que de otro modo reenviaría 20.000 tokens en cada turno se reduce a unos pocos miles.

Lectura del saldo y del ID de petición

Cada respuesta incluye X-Request-Id y X-Balance-USD. El SDK oculta los encabezados por defecto, pero with_raw_response los expone mientras aún te da el objeto analizado.

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance USD:", raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Registra el ID de petición con cada fallo. Si necesitas contactar al equipo a través de la página de soporte, ese ID apunta directamente a la llamada.

El encabezado de saldo es útil más allá del registro. Un trabajo programado puede leerlo después de cada lote y detenerse cuando el crédito cae por debajo de un umbral que configures, o enviarte un mensaje para que recargues antes de que los usuarios lo noten. El crédito no caduca, así que no hay presión para gastarlo. Las recargas son montos enteros de $20 a $500, así que puedes recargar en pasos más grandes si lo prefieres.

Sin el SDK: requests o httpx

Si prefieres evitar la dependencia, la API es lo suficientemente simple para un cliente HTTP estándar.

import requests

r = requests.post(
    "https://api.openaiapiproxy.com/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "uncensored",
        "messages": [{"role": "user", "content": "Name three sea shanty topics."}],
    },
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

Establece un tiempo de espera generoso para finalizaciones largas. El modelo puede usar tanto de la ventana de 100.000 tokens como deje libre el prompt, por lo que una petición sin límite para ficción larga puede tardar un poco.

El mismo enfoque funciona para streaming. Añade "stream": true al cuerpo JSON, pasa stream=True a requests.post y lee la respuesta con iter_lines(). Cada línea de evento comienza con data: seguido de JSON, y el flujo termina con un marcador data: [DONE]. Analizar eso manualmente es un buen ejercicio de aprendizaje, aunque para código de producción el SDK lo hace con menos casos extremos, como líneas parciales y reconexiones.

Gestión del presupuesto dentro de tu código Python

Los recuentos de tokens en resp.usage te permiten calcular el gasto por llamada. El precio es $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida.

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
    return prompt_tokens * 0.15 / 1_000_000 + completion_tokens * 0.50 / 1_000_000

r = client.chat.completions.create(model="uncensored", messages=[{"role": "user", "content": "Hi"}])
print(cost_usd(r.usage.prompt_tokens, r.usage.completion_tokens))
print(cost_usd(1_000_000, 200_000))  # 0.25

La segunda línea se verifica manualmente: 1M tokens de entrada cuestan $0.15 y 200.000 tokens de salida cuestan 0.2 x $0.50 = $0.10, lo que suma $0.25. Las peticiones fallidas o rechazadas no se cobran, así que no necesitas restarlas. Las recargas comienzan en $20, y la página de precios lista los bonos en $50, $100 y $200.

Para la lista completa de parámetros y códigos de error, consulta la documentación.

Mantén un total acumulado en tu trabajo para que un bucle no gaste más de lo planeado. Un trabajo por lotes que clasifica 50.000 textos cortos con 400 tokens de entrada y 20 tokens de salida cada uno usa 20M de tokens de entrada y 1M de tokens de salida. Eso cuesta 20 x $0,15 + 1 x $0,50 = $3,50. Si tu contador dice que el trabajo está al doble de eso, algo está en bucle.

Preguntas y respuestas

¿Necesito un paquete de Python especial?

No. El paquete oficial openai es suficiente. Establece base_url y api_key en el cliente y usa el nombre del modelo uncensored.

¿Funciona el cliente asíncrono?

Sí. AsyncOpenAI acepta los mismos argumentos. Limita la concurrencia a 8 peticiones con una clave completa, o 2 con una clave de prueba.

¿Cómo veo mi crédito restante desde el código?

Lee el encabezado de respuesta X-Balance-USD. En el paquete openai, usa with_raw_response y luego lee raw.headers.

¿Qué ocurre con un error 429?

El código de error rate_limited o concurrency te indica qué límite superaste. El SDK reintenta por defecto y se envía un encabezado Retry-After en caso de sobrecarga temporal.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

Obtener clave de API