Guide complet Workers AI : 10 000 appels LLM gratuits par jour, 90 % moins cher qu'OpenAI

Ma facture OpenAI API avait dépassé 200 dollars en un mois, juste pour quelques jours de tests sur un petit projet. Workers AI est l’alternative que j’ai trouvée en explorant les capacités edge de Cloudflare : 10 000 Neurons gratuits par jour ; après une semaine d’usage personnel, le quota couvre largement mes conversations quotidiennes.

Cet article présente les trois modes d’appel de Workers AI, ainsi que les configurations à modifier pour migrer depuis OpenAI.

Qu’est-ce que Workers AI ? Pourquoi s’y intéresser ?

En bref, Workers AI est le service d’inférence IA serverless lancé par Cloudflare. Pas besoin d’acheter un GPU ni de gérer un serveur : quelques lignes de code suffisent pour appeler Llama, Mistral et d’autres grands modèles open source.

Trois points clés :

1. 10 000 Neurons gratuits par jour

   • En pratique, cela couvre plusieurs centaines de conversations ; largement suffisant pour un projet personnel
   • Avec Llama 3.1-8B, j’ai testé 1 000 conversations simples pour environ 8 000 Neurons consommés

2. Tarif payant très bas : 0,011 $/1 000 Neurons

   • 60 à 70 % moins cher que OpenAI GPT-3.5
   • Plus de 90 % moins cher que GPT-4

3. Accélération via le réseau edge mondial

   • Cloudflare compte plus de 300 nœuds
   • Temps de réponse souvent plus rapide que chez de nombreux fournisseurs cloud

Comparaison avec d’autres solutions

Vous vous demandez peut-être : le gratuit, est-ce vraiment utilisable ? Voici un tableau comparatif :

Quand Workers AI convient-il ?

• ✅ Projets personnels, validation de prototypes, expérimentation
• ✅ Applications de production à petite/moyenne échelle (QPS < 300)
• ✅ Startups sensibles aux coûts

Quand ce n’est pas idéal ?

• ⚠️ Traitement batch à très grande échelle (centaines de milliers d’appels/jour)
• ⚠️ Applications temps réel ultra sensibles à la latence (< 100 ms)
• ⚠️ Besoin de modèles de niveau GPT-4 le plus récent

"Tests avec Llama 3.1-8B sur des dialogues en chinois : Q&R simples (< 100 caractères) consomment 5 à 8 Neurons par appel ; résumé de texte long (1 000 caractères en entrée) : 30 à 50 Neurons ; génération de code (500 lignes) : 20 à 40 Neurons."

Le quota gratuit suffit-il ? Faisons le calcul

Les « Neurons » sont l’unité de facturation propre à Cloudflare ; au début, j’étais un peu perdu. En résumé :

Neurons = (tokens d’entrée + tokens de sortie) × coefficient du modèle

Le coefficient varie selon le modèle :

• Llama 3.1-8B : coefficient ~ 0,8
• Llama 3.1-70B : coefficient ~ 3,5
• Mistral 7B : coefficient ~ 0,7

Combien d’appels en pratique ?

Avec ces consommations, 10 000 Neurons par jour permettent environ :

• 1 000 à 2 000 conversations simples
• 200 à 300 traitements de textes longs
• 250 à 500 générations de code

Franchement, pour un développeur solo, c’est largement suffisant. J’utilise Workers AI pour un petit bot qui traite plusieurs centaines de messages par jour, toujours dans le quota gratuit.

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

Commencer →Pub

Et si vous dépassez le quota gratuit ?

Le passage en mode payant est automatique : 0,011 $/1 000 Neurons.

J’ai calculé : même en dépassant, le coût reste faible :

• Supposons 50 000 Neurons/jour (5× le quota gratuit)
• Partie excédentaire : 40 000 Neurons
• Coût : 40 000 / 1 000 × 0,011 $ = 0,44 $/jour
• Soit environ 13 $/mois

Comparé à OpenAI : le même volume pourrait coûter 50 à 100 $ ; Workers AI est nettement moins cher.

Démarrage rapide : trois façons d’appeler Workers AI

Prérequis simples :

1. Créer un compte Cloudflare (gratuit)
2. Installer Node.js (pour les méthodes 2 et 3)

Voici trois modes d’appel, du plus simple au plus avancé ; choisissez selon vos besoins.

Méthode 1 : la plus simple — REST API directe

C’est le moyen le plus rapide de tester, sans écrire de code : une commande curl suffit.

Étape 1 : obtenir le token API et l’Account ID

1. Connectez-vous à Cloudflare : https://dash.cloudflare.com
2. L’URL affiche https://dash.cloudflare.com/xxxxxxxxx ; cette chaîne xxxxxxxxx est votre Account ID — copiez-la
3. Cliquez sur l’avatar en haut à droite → My Profile → API Tokens
4. Cliquez sur « Create Token » → trouvez le modèle « Workers AI » → « Use template »
5. À la fin, un token est généré — affiché une seule fois, conservez-le impérativement

Étape 2 : tester l’appel

Ouvrez un terminal et exécutez (remplacez Account ID et Token) :

curl https://api.cloudflare.com/client/v4/accounts/{VOTRE_Account_ID}/ai/run/@cf/meta/llama-3.1-8b-instruct \
  -H "Authorization: Bearer {VOTRE_API_Token}" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant IA amical"},
      {"role": "user", "content": "Présentez Cloudflare Workers AI en une phrase"}
    ]
  }'

Si vous obtenez un JSON similaire à celui-ci, c’est réussi :

{
  "result": {
    "response": "Cloudflare Workers AI est une plateforme d'inférence IA serverless..."
  },
  "success": true
}

Erreurs courantes :

• Erreur 7003 : Token ou Account ID incorrect — vérifiez la copie complète
• Erreur 10000 : nom de modèle incorrect — c’est @cf/meta/llama-3.1-8b-instruct, ne oubliez pas @cf/
• Timeout : le premier appel peut être lent (cold start) ; attendez ~10 s, les suivants seront plus rapides

Méthode 2 : recommandée — déploiement Workers + Wrangler

Approche officielle recommandée : déployer une API permanente avec une gestion de configuration plus simple.

Étape 1 : installer Wrangler CLI

npm install -g wrangler

Puis connectez-vous à Cloudflare :

wrangler login

Le navigateur s’ouvre pour autoriser ; acceptez.

Étape 2 : créer le projet Worker

npm create cloudflare@latest my-ai-worker

Répondez ainsi aux questions :

• Select a project type : « Hello World » Worker
• Do you want to use TypeScript? Selon préférence ; j’ai choisi No (JavaScript)
• Do you want to use git? Yes
• Do you want to deploy? No pour l’instant ; déployez après les tests

Étape 3 : configurer le binding Workers AI

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

Dans le répertoire du projet, éditez wrangler.toml et ajoutez à la fin :

[ai]
binding = "AI"

Vous pourrez alors accéder à Workers AI via env.AI dans le code, sans passer le token manuellement.

Étape 4 : écrire le code

Éditez src/index.js (ou index.ts) :

export default {
  async fetch(request, env) {
    // Gestion CORS (appels depuis une page web)
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': '*',
          'Access-Control-Allow-Methods': 'POST',
          'Access-Control-Allow-Headers': 'Content-Type',
        },
      });
    }

    // Accepter uniquement POST
    if (request.method !== 'POST') {
      return new Response('Method not allowed', { status: 405 });
    }

    try {
      const { messages } = await request.json();

      const response = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
        messages: messages || [
          { role: 'user', content: 'Hello!' }
        ]
      });

      return new Response(JSON.stringify(response), {
        headers: {
          'Content-Type': 'application/json',
          'Access-Control-Allow-Origin': '*',
        },
      });

    } catch (error) {
      return new Response(JSON.stringify({ error: error.message }), {
        status: 500,
        headers: { 'Content-Type': 'application/json' },
      });
    }
  },
};

Étape 5 : test local

wrangler dev

Serveur local, généralement http://localhost:8787.

Test avec curl :

curl http://localhost:8787 \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Présentez-vous brièvement"}
    ]
  }'

Si la réponse est correcte, déployez.

Étape 6 : déploiement en production

wrangler deploy

Après déploiement, vous obtenez un domaine *.workers.dev, par exemple :

https://my-ai-worker.your-name.workers.dev

C’est l’adresse de votre API IA, appelable depuis n’importe où.

Méthode 3 : migration transparente avec le SDK OpenAI

Si vous utilisiez l’API OpenAI et souhaitez passer à Workers AI, c’est la méthode la plus pratique — presque aucun changement de code.

Workers AI expose un point de terminaison compatible OpenAI ; il suffit de modifier le baseURL.

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.CLOUDFLARE_API_TOKEN, // Votre token Cloudflare
  baseURL: `https://api.cloudflare.com/client/v4/accounts/${process.env.ACCOUNT_ID}/ai/v1`,
});

// Appel identique à OpenAI
const chatCompletion = await client.chat.completions.create({
  model: '@cf/meta/llama-3.1-8b-instruct', // Modèle Workers AI
  messages: [
    { role: 'system', content: 'Vous êtes un assistant IA amical' },
    { role: 'user', content: 'Hello!' }
  ],
});

console.log(chatCompletion.choices[0].message.content);

Points d’attention :

• apiKey : token API Cloudflare
• baseURL : point de terminaison Workers AI
• model : modèle Workers AI pris en charge (préfixe @cf/)

J’avais un projet Next.js sur OpenAI ; migration vers Workers AI en 10 minutes, trois modifications seulement.

Quels modèles utiliser ? Comment choisir ?

Workers AI prend en charge plus de 50 modèles ; voici les plus courants.

Modèles de génération de texte (les plus utilisés)

Mes recommandations :

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

1. Premier essai : Llama 3.1-8B

   • Réponse rapide (1 à 2 s)
   • Qualité comparable à GPT-3.5
   • Faible consommation de Neurons

2. Exigence plus élevée : Llama 3.1-70B ou DeepSeek-R1

   • Meilleur raisonnement
   • Qualité proche de GPT-4
   • Plus lent (3 à 5 s), consommation 3 à 4× supérieure

3. Longs documents : Mistral 7B v0.2

   • Fenêtre de contexte 32k (Llama 3.1 : 8k)
   • Adapté aux articles longs, gros blocs de code

Cas pratiques : trois exemples concrets

Cas 1 : API de questions-réponses (le plus simple)

Scénario : ajouter un assistant IA à votre blog ou site documentaire.

Code complet (basé sur la méthode 2) :

export default {
  async fetch(request, env) {
    const corsHeaders = {
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Methods': 'POST, OPTIONS',
      'Access-Control-Allow-Headers': 'Content-Type',
    };

    if (request.method === 'OPTIONS') {
      return new Response(null, { headers: corsHeaders });
    }

    try {
      const { question } = await request.json();

      const messages = [
        {
          role: 'system',
          content: 'Vous êtes l\'assistant IA d\'un blog technique, spécialisé en développement web et applications IA. Réponses concises et amicales.'
        },
        {
          role: 'user',
          content: question
        }
      ];

      const response = await env.AI.run(
        '@cf/meta/llama-3.1-8b-instruct',
        { messages }
      );

      return new Response(
        JSON.stringify({ answer: response.response }),
        { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
      );

    } catch (error) {
      return new Response(
        JSON.stringify({ error: 'Échec du traitement, réessayez plus tard' }),
        { status: 500, headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
      );
    }
  }
};

Estimation des coûts : 200 utilisateurs/jour, 10 Neurons par conversation → 2 000 Neurons, dans le quota gratuit.

Cas 2 : génération batch de résumés

Scénario : produire des résumés pour de nombreux articles (flux RSS, agrégation d’actualités).

async function generateSummary(text, env) {
  const messages = [
    {
      role: 'system',
      content: 'Vous êtes un assistant de résumé professionnel. Résumez l\'article en 2 à 3 phrases en mettant en avant les idées clés.'
    },
    {
      role: 'user',
      content: `Résumez l'article suivant :\n\n${text}`
    }
  ];

  const response = await env.AI.run(
    '@cf/meta/llama-3.1-8b-instruct',
    {
      messages,
      max_tokens: 150 // Limiter la sortie pour économiser des Neurons
    }
  );

  return response.response;
}

Limites de débit :

• Llama 3.1-8B : 300 requêtes/minute
• Pour le batch, ajoutez des délais ou une file d’attente

Exemple de coût :

• Article de 1 000 caractères, résumé de 100 caractères
• ~30 Neurons par appel
• 300 articles = 9 000 Neurons, toujours dans le quota gratuit

Cas 3 : service de traduction multilingue

Scénario : outil de traduction ou internationalisation d’application.

async function translate(text, targetLang, env) {
  const messages = [
    {
      role: 'system',
      content: `Vous êtes un assistant de traduction professionnel. Traduisez l'entrée en ${targetLang}, en conservant le style et le ton. Retournez uniquement la traduction, sans explication.`
    },
    {
      role: 'user',
      content: text
    }
  ];

  const response = await env.AI.run(
    '@cf/meta/llama-3.1-8b-instruct',
    { messages }
  );

  return response.response;
}

Comparaison des coûts :

• Google Cloud Translation API : 20 $/million de caractères
• Workers AI (Llama 3.1) : ~1,65 $/million de caractères

Plus de 10× moins cher !

Conclusion : Workers AI vaut-il le coup ?

Après un mois de tests, ma conclusion : pour les développeurs solo et les petites équipes, clairement oui.

Avantages :

• ✅ Quota gratuit généreux (10 000 Neurons/jour)
• ✅ Tarif payant bas (60 à 90 % moins cher qu’OpenAI)
• ✅ Prise en main simple (REST API et compatibilité OpenAI)
• ✅ Réponses rapides (réseau edge mondial)
• ✅ Large choix de modèles (50+ open source)

Mes conseils :

1. Projets personnels : foncez — quota gratuit suffisant, plus de serveur à gérer
2. Startups : commencez ici — migrez ailleurs quand l’échelle le justifie
3. Entreprise : évaluez prudemment — SLA, conformité des données, etc.

Si vous cherchez une solution IA low-cost, essayez Workers AI. Compte en 5 minutes, premier exemple en 15 — peut-être que ça vous conviendra.