L'API OpenAI expire ? Créez un canal privé avec Workers, zéro coût et plus stable

Introduction

La semaine dernière, je voulais développer une application ChatGPT. Le frontend était prêt, mais les appels API expiraient — OpenAI n’est pas accessible depuis la Chine continentale. J’ai essayé des proxies achetés en ligne, toujours inquiets de leur fiabilité et du risque de fuite de clé API. J’ai aussi envisagé un VPS, mais c’est plusieurs dizaines de dollars par mois plus la configuration et la maintenance du serveur.
Puis j’ai découvert Cloudflare Workers : zéro coût, opérationnel en 5 minutes. Deux mois d’utilisation plus tard, je confirme — stable, et souvent plus rapide que bien des proxies payants. Cet article partage le processus complet de mise en place, avec du code prêt à l’emploi.

Pourquoi choisir Cloudflare Workers ?

Zéro coût, suffisant pour les développeurs individuels

L’offre gratuite Workers vous donne 100 000 requêtes par jour et 1 000 par minute. Vous vous demandez peut-être si le gratuit tient la route ? Moi aussi au début. En pratique, pour le développement personnel, l’apprentissage ou les petits projets, ce quota est largement suffisant.
Faisons le calcul : en supposant 2 secondes par requête en moyenne, 8 heures de travail continu, vous n’atteignez qu’environ 2 000 appels. Avec 100 000 requêtes, il faudrait plusieurs jours d’utilisation intensive pour épuiser le quota.

Pas de serveur à acheter, zéro tracas

Les solutions traditionnelles impliquent un VPS, Nginx en reverse proxy, et la crainte d’une panne serveur. Workers n’a besoin de rien de tout cela — Cloudflare gère toute l’infrastructure, vous n’écrivez que quelques lignes de code.
De plus, Workers tourne sur le réseau CDN mondial de Cloudflare, théoriquement plus rapide qu’un serveur unique que vous hébergeriez vous-même. Cloudflare est présent dans plus de 300 villes dans le monde.

Protection native des clés API

C’est un point crucial. Si vous appelez l’API OpenAI directement depuis le frontend, la clé sera exposée dans le navigateur — n’importe qui ouvrant les outils de développement peut la voir. Avec Workers comme couche intermédiaire, le frontend n’appelle que l’URL de votre Worker, tandis que la vraie clé API reste en sécurité dans les variables d’environnement Cloudflare.

"En août 2025, Cloudflare s’est associé à OpenAI pour intégrer les modèles open source d’OpenAI directement dans Workers AI, avec 10 000 Neurons gratuits par jour"

Nouveauté 2025

Au passage, en août 2025, Cloudflare et OpenAI ont aussi intégré les modèles open source d’OpenAI dans Workers AI. Outre le proxy de l’API originale, vous pouvez utiliser directement les modèles fournis par Cloudflare, avec 10 000 Neurons gratuits par jour.

Préparation avant la mise en place

La préparation est très simple. Il vous faut :
Comptes et ressources :

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

• Un compte Cloudflare (inscription gratuite, quelques minutes)
• Une clé API OpenAI ou Claude (vous l’avez probablement déjà)
• Un domaine (optionnel, Workers fournit un sous-domaine .workers.dev gratuit)
  Prérequis techniques :
• Un peu de JavaScript (suffit de comprendre les requêtes fetch)
• Comprendre le fonctionnement de HTTP
  Temps nécessaire :
• Première mise en place : 5 à 10 minutes
• Une fois familiarisé : 3 minutes

Mise en pratique : proxy OpenAI en 5 minutes

Étape 1 : créer un Worker

Connectez-vous à la console Cloudflare, menu de gauche « Workers & Pages ». Cliquez sur « Create Application », puis « Create Worker ».
Cloudflare attribue un nom aléatoire (par ex. aged-shadow-1234) ; vous pouvez le renommer, par ex. « openai-proxy ». Cliquez sur « Deploy ».
Vous avez déjà un Worker fonctionnel, même s’il ne fait encore rien.

Étape 2 : écrire le code

Cliquez sur « Edit Code » pour ouvrir l’éditeur et collez le code suivant :

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    // Remplacer le domaine par l'adresse API OpenAI
    url.hostname = 'api.openai.com';
    // Créer une nouvelle requête
    const newRequest = new Request(url, {
      method: request.method,
      headers: request.headers,
      body: request.body
    });
    // Transférer la requête et renvoyer la réponse
    const response = await fetch(newRequest);
    // Gérer le 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;
  }
};

Voici ce que fait ce code :

1. Reçoit la requête du frontend
2. Remplace le domaine par api.openai.com
3. Transfère la requête modifiée à OpenAI
4. Renvoie la réponse d’OpenAI telle quelle au frontend
5. Gère aussi le CORS (cross-origin)
   Cliquez sur « Save and Deploy ».

Étape 3 : tester

Après le déploiement, vous obtenez une URL Worker, par ex. https://openai-proxy.votrenom.workers.dev.
Testez avec curl (remplacez YOUR_API_KEY par votre clé OpenAI) :

curl https://openai-proxy.votrenom.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 vous voyez une réponse normale d’OpenAI, félicitations, c’est réussi !

Avancé : prendre en charge plusieurs services IA

Proxy API Claude

La structure de l’API Claude diffère un peu d’OpenAI, surtout au niveau des en-têtes. Modifiez le code pour Claude :

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    // Déterminer le service selon le chemin
    if (url.pathname.startsWith('/claude')) {
      // Retirer le préfixe /claude, transférer vers Anthropic
      url.pathname = url.pathname.replace('/claude', '');
      url.hostname = 'api.anthropic.com';
    } else {
      // Par défaut : 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;
  }
};

L’accès à /claude/v1/messages transfère désormais vers l’API Claude.

Proxy API Gemini

L’endpoint Gemini de Google est generativelanguage.googleapis.com ; ajoutez une condition :

Alibaba Cloud - Choix n°1 des développeurs, 15 % de réduction exclusive sur Lighthouse

Obtenir -15 % →Pub

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

Un seul Worker peut ainsi proxy les trois services IA.

Bonnes pratiques de sécurité

Ne codez pas la clé API en dur

Certains tutoriels mettent la clé API directement dans le code Worker — ne faites surtout pas ça ! Le code est stocké en clair et peut être partagé par inadvertance.
La bonne approche : les variables d’environnement. Dans les paramètres du Worker, « Variables and Secrets », ajoutez :

• Nom : OPENAI_API_KEY
• Valeur : votre clé API
• Type : « Secret » (stockage chiffré)
  Puis dans le code :

export default {
  async fetch(request, env) {
    // Lire la clé API depuis les variables d'environnement
    const apiKey = env.OPENAI_API_KEY;
    // Modifier les en-têtes, ajouter la clé API
    const headers = new Headers(request.headers);
    headers.set('Authorization', `Bearer ${apiKey}`);
    // Le reste du code comme avant...
  }
};

Le frontend n’a plus besoin de transmettre la clé API, c’est plus sûr.

Ajouter un token d’authentification personnalisé

Si vous craignez qu’une URL Worker divulguée soit abusée, ajoutez une couche d’authentification simple :

export default {
  async fetch(request, env) {
    // Vérifier le token personnalisé
    const authToken = request.headers.get('X-Custom-Auth');
    if (authToken !== env.MY_SECRET_TOKEN) {
      return new Response('Unauthorized', { status: 401 });
    }
    // Authentification OK, continuer le traitement...
  }
};

Définissez MY_SECRET_TOKEN en variable d’environnement ; le frontend envoie cet en-tête personnalisé.

Surveiller la consommation

La console Cloudflare propose un onglet Analytics : volume quotidien, taux d’erreur, etc. Consultez-le régulièrement pour détecter un dépassement du quota gratuit.
Vous pouvez aussi configurer une alerte : dans « Notifications », créez une règle pour un e-mail quand le volume approche 100 000 requêtes.

Problèmes courants et solutions

Requêtes lentes ou timeout

Si les réponses sont très lentes, le nœud Worker assigné n’est peut-être pas optimal.
Solution : liez un domaine personnalisé. Cloudflare optimise le routage selon la configuration DNS de votre domaine, généralement plus rapide que le domaine .workers.dev gratuit.
Dans les paramètres du Worker : « Triggers » → « Add Custom Domain », saisissez votre domaine (par ex. api.votredomaine.com) et ajoutez l’enregistrement DNS indiqué.

KiloClaw - OpenClaw managé pour l’entreprise : orchestration d’agents IA et routage intelligent

Commencer →Pub

Erreurs 403 ou 401

En général, c’est un problème de clé API :

1. Vérifiez que le nom de la variable d’environnement correspond au code
2. Confirmez que la clé API est valide et a du crédit
3. Vérifiez les restrictions géographiques d’OpenAI/Claude (Workers est mondial, mais certains nœuds peuvent être identifiés)
   Astuce de débogage : ajoutez des logs :

console.log('API Key:', env.OPENAI_API_KEY ? 'définie' : 'non définie');

Puis consultez les logs en temps réel dans l’onglet « Logs » du Worker.

Et si le quota gratuit ne suffit pas ?

Si 100 000 requêtes ne suffisent vraiment pas (projet commercial, par ex.), envisagez l’offre payante :

• Workers payant : 5 $/mois, 10 millions de requêtes incluses
• Dépassement : 0,50 $ par million de requêtes supplémentaires
  Pour les applications petites et moyennes, c’est souvent plus rentable qu’un VPS, sans maintenance serveur — le temps gagné vaut bien plus.

Conseils d’optimisation :

1. Mettez en cache côté frontend, évitez les appels identiques répétés
2. Utilisez les interfaces batch (si l’API le permet) pour réduire le nombre de requêtes
3. En développement, utilisez des données mock plutôt que l’API réelle en permanence

Conclusion

En résumé, le proxy Workers repose sur trois atouts :

• Zéro coût : le quota gratuit suffit largement pour le développement personnel
• Zéro barrière : configuration en 5 minutes, moins de 30 lignes de code
• Zéro risque : clé API stockée en sécurité, pas de fuite
  Cette approche convient particulièrement à l’apprentissage personnel, aux démos et aux petits projets. Si vous cherchez un accès stable aux API IA, essayez Workers.
  Lancez-vous ! Gardez cet article sous la main pour revenir en cas de blocage. Si vous rencontrez d’autres pièges, partagez-les en commentaire — j’aimerais savoir ce qu’on peut encore améliorer.
  Les projets open source mentionnés valent le détour, notamment chatgptProxyAPI et worker-openai-proxy — code très clair, à consulter sur GitHub.
  Quelle solution utilisez-vous pour accéder aux API IA ? Discutons-en en commentaire !