¿La API de OpenAI siempre hace timeout? Crea un canal privado con Workers, sin costo y más estable

Introducción

La semana pasada quise desarrollar una app con ChatGPT. Al terminar el frontend y llamar a la API, la conexión hizo timeout: OpenAI no es accesible desde China. Probé proxies comprados en línea, pero siempre me preocupaba su fiabilidad y el riesgo de filtrar la API Key. También pensé en comprar un VPS, pero son decenas de dólares al mes y además hay que configurar y mantener el servidor.

Luego descubrí Cloudflare Workers: no cuesta nada y se monta en 5 minutos. Llevo más de dos meses usándolo y la verdad es que funciona muy bien: no solo es estable, sino que en muchos casos va más rápido que proxies de pago. En este artículo comparto el proceso completo de montaje, con código listo para usar.

¿Por qué elegir Cloudflare Workers?

Sin costo, suficiente para desarrolladores individuales

El plan gratuito de Workers te da 100.000 peticiones al día y 1.000 por minuto. Quizá te preguntes: ¿algo gratis puede funcionar bien? Yo también lo pensé al principio. Pero en la práctica, para desarrollo personal, aprendizaje o proyectos pequeños, la cuota sobra.

Hagamos cuentas: si cada petición tarda unos 2 segundos y trabajas 8 horas seguidas sin parar, harías unas 2.000 peticiones. Con 100.000 de cuota, tardarías varios días seguidos en agotarla.

Sin comprar servidor, más tranquilidad

El enfoque tradicional requiere un VPS, instalar Nginx, configurar un proxy inverso y preocuparse por caídas del servidor. Workers no necesita nada de eso: Cloudflare se encarga de toda la infraestructura y tú solo escribes unas líneas de código.

Además, Workers corre en la red CDN global de Cloudflare, así que en teoría es más rápido que un solo servidor que montes tú. Cloudflare tiene nodos en más de 300 ciudades del mundo.

Protección natural de la API Key

Este punto es clave. Si llamas a la API de OpenAI directamente desde el frontend, la clave queda expuesta en el navegador: cualquiera puede verla en las herramientas de desarrollo. Con Workers como capa intermedia, el frontend solo llama a tu Worker y la API Key real queda guardada de forma segura en las variables de entorno de Cloudflare.

"En agosto de 2025 Cloudflare y OpenAI integraron los modelos open source de OpenAI directamente en Workers AI, con 10.000 Neurons gratis al día"

La novedad de 2025

Por cierto, en agosto de 2025 Cloudflare y OpenAI también integraron los modelos open source de OpenAI en Workers AI. Eso significa que, además de hacer proxy de la API original, puedes usar directamente los modelos que ofrece Cloudflare, con 10.000 Neurons gratis al día.

Preparativos antes de montar

La preparación es muy sencilla. Necesitas:

Cuentas y recursos:

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

• Cuenta de Cloudflare (registro gratuito, en pocos minutos)
• API Key de OpenAI o Claude (seguramente ya la tienes)
• Dominio (opcional; Workers te da un subdominio gratuito .workers.dev)

Requisitos técnicos:

• Un poco de JavaScript (basta con entender peticiones fetch)
• Conocer lo básico de HTTP

Tiempo:

• Primera vez: 5-10 minutos
• Cuando ya lo domines: 3 minutos

Práctica: montar un proxy de OpenAI en 5 minutos

Paso 1: crear el Worker

Inicia sesión en la consola de Cloudflare y en el menú lateral busca “Workers & Pages”. Haz clic en “Create Application” y elige “Create Worker”.

Cloudflare asignará un nombre aleatorio (por ejemplo aged-shadow-1234); puedes cambiarlo por el que quieras, como “openai-proxy”. Haz clic en “Deploy”.

En este punto ya tienes un Worker en ejecución, aunque aún no hace nada.

Paso 2: escribir el código

Haz clic en “Edit Code” para abrir el editor y pega este código:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    // Reemplazar el dominio por la API de OpenAI
    url.hostname = 'api.openai.com';
    // Crear nueva petición
    const newRequest = new Request(url, {
      method: request.method,
      headers: request.headers,
      body: request.body
    });
    // Reenviar petición y devolver respuesta
    const response = await fetch(newRequest);
    // Gestionar CORS
    const newResponse = new Response(response.body, response);
    newResponse.headers.set('Access-Control-Allow-Origin', '*');
    newResponse.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
    newResponse.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
    return newResponse;
  }
};

En resumen, el código hace lo siguiente:

1. Recibe la petición del frontend
2. Cambia el dominio de la URL a api.openai.com
3. Reenvía la petición modificada a OpenAI
4. Devuelve la respuesta de OpenAI tal cual al frontend
5. Gestiona CORS

Haz clic en “Save and Deploy” para guardar.

Paso 3: probar

Tras el despliegue verás la URL del Worker, por ejemplo https://openai-proxy.tu-nombre.workers.dev.

Prueba con curl (sustituye YOUR_API_KEY por tu clave de OpenAI):

curl https://openai-proxy.tu-nombre.workers.dev/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Si ves la respuesta normal de OpenAI, ¡listo!

Avanzado: soportar varios servicios de IA

Proxy de la API de Claude

La API de Claude tiene una estructura distinta a la de OpenAI, sobre todo en los headers. Modifica el código para soportar Claude:

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    // Determinar el servicio según la ruta
    if (url.pathname.startsWith('/claude')) {
      // Quitar prefijo /claude y reenviar a Anthropic
      url.pathname = url.pathname.replace('/claude', '');
      url.hostname = 'api.anthropic.com';
    } else {
      // Por defecto OpenAI
      url.hostname = 'api.openai.com';
    }
    const newRequest = new Request(url, {
      method: request.method,
      headers: request.headers,
      body: request.body
    });
    const response = await fetch(newRequest);
    const newResponse = new Response(response.body, response);
    newResponse.headers.set('Access-Control-Allow-Origin', '*');
    return newResponse;
  }
};

Ahora, al acceder a /claude/v1/messages, la petición se reenvía a la API de Claude.

Proxy de la API de Gemini

El endpoint de Gemini de Google es generativelanguage.googleapis.com; basta con añadir una condición:

Alibaba Cloud - Opción preferida para desarrolladores, 15 % de descuento exclusivo en Lighthouse

Obtener 15% dto. →Anuncio

if (url.pathname.startsWith('/gemini')) {
  url.pathname = url.pathname.replace('/gemini', '');
  url.hostname = 'generativelanguage.googleapis.com';
}

Así un solo Worker puede hacer proxy de los tres servicios de IA.

Buenas prácticas de seguridad

No hardcodees la API Key

En algunos tutoriales ponen la API Key directamente en el código del Worker. ¡No lo hagas! El código se guarda en texto plano y puede compartirse por error.

La forma correcta es usar variables de entorno. En la configuración del Worker, busca “Variables and Secrets” y añade una variable:

• Nombre: OPENAI_API_KEY
• Valor: tu API Key
• Tipo: “Secret” (almacenamiento cifrado)

En el código:

export default {
  async fetch(request, env) {
    // Leer API Key desde variables de entorno
    const apiKey = env.OPENAI_API_KEY;
    // Añadir API Key al header
    const headers = new Headers(request.headers);
    headers.set('Authorization', `Bearer ${apiKey}`);
    // El resto del código igual que antes...
  }
};

Así el frontend no necesita enviar la API Key: más seguro.

Añade un token de autenticación personalizado

Si te preocupa que alguien abuse de tu Worker al conocer la URL, añade una capa simple de autenticación:

export default {
  async fetch(request, env) {
    // Comprobar token personalizado
    const authToken = request.headers.get('X-Custom-Auth');
    if (authToken !== env.MY_SECRET_TOKEN) {
      return new Response('Unauthorized', { status: 401 });
    }
    // Autenticación OK, continuar con la petición...
  }
};

Configura MY_SECRET_TOKEN en variables de entorno y envía ese header personalizado desde el frontend.

Monitorizar el uso

En la consola de Cloudflare hay una pestaña Analytics con peticiones diarias, tasa de errores y más. Conviene revisarla de vez en cuando por si te acercas al límite gratuito.

También puedes crear alertas: en “Notifications” define una regla para que te envíe un correo cuando el volumen se acerque a 100.000 peticiones.

Problemas frecuentes y soluciones

Peticiones lentas o timeout

Si las respuestas van muy lentas, puede que el nodo asignado al Worker no sea el ideal.

Solución: vincula un dominio personalizado. Cloudflare optimiza la ruta según la configuración DNS de tu dominio y suele ir más rápido que el subdominio gratuito .workers.dev.

En la configuración del Worker: “Triggers” → “Add Custom Domain”, introduce tu dominio (por ejemplo api.tudominio.com) y sigue las instrucciones para añadir el registro DNS.

Errores 403 o 401

Suele ser un problema con la API Key:

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

1. Comprueba que el nombre de la variable de entorno coincida con el del código
2. Verifica que la API Key sea válida y tenga saldo
3. Revisa si OpenAI/Claude tienen restricciones geográficas (aunque Workers está distribuido globalmente, algunos nodos pueden ser detectados)

Truco de depuración: añade logs en el código:

console.log('API Key:', env.OPENAI_API_KEY ? 'configurada' : 'no configurada');

Luego revisa los logs en tiempo real en la pestaña “Logs” del Worker.

¿Qué hacer si la cuota gratuita no alcanza?

Si 100.000 peticiones no te bastan (por ejemplo en un proyecto comercial), considera el plan de pago:

• Plan de pago de Workers: $5/mes, incluye 10 millones de peticiones
• Excedente: $0.50 por cada millón adicional

Para apps pequeñas y medianas, suele salir más barato que un VPS, y sin mantener servidores: el tiempo ahorrado también cuenta.

Sugerencias de optimización:

1. Cachea en el frontend: no repitas la misma petición
2. Usa APIs por lotes (si el servicio lo permite) para reducir peticiones
3. En desarrollo usa datos mock en lugar de llamar siempre a la API real

Conclusión

En resumen, las ventajas del proxy con Workers son tres:

• Sin costo: la cuota gratuita sobra para desarrollo personal
• Sin barrera: configuración en 5 minutos, menos de 30 líneas de código
• Sin riesgo: la API Key se guarda de forma segura, sin filtraciones

Este enfoque encaja muy bien para aprendizaje, demos y proyectos pequeños. Si buscas una forma estable de acceder a APIs de IA, Workers merece la pena.

¡Pruébalo ya! Guarda este artículo y vuelve cuando tengas dudas. Si encuentras otros problemas al montarlo, cuéntalo en los comentarios: también quiero saber qué se puede mejorar.

Por cierto, los proyectos open source que menciono son muy buenos, sobre todo chatgptProxyAPI y worker-openai-proxy: el código es claro y vale la pena estudiarlo en GitHub.

¿Qué solución usas tú para acceder a APIs de IA? Cuéntalo en los comentarios.