- API IA gratuites : le guide complet avec exemples

Panorama des API IA gratuites en 2026

Intégrer un LLM dans une application ne coûte plus rien pour démarrer. En 2026, une dizaine de fournisseurs proposent une clé d'API gratuite, sans carte bancaire pour la plupart, avec des quotas largement suffisants pour un prototype, un side-project ou une démo. Ce guide recense toutes les API IA gratuites qui comptent et fournit, pour chacune, un exemple d'implémentation prêt à copier en JavaScript/Node.js.

Bonne nouvelle pour la portabilité : la grande majorité expose un endpoint compatible OpenAI. Changer de fournisseur revient souvent à modifier trois choses — l'URL de base (baseURL), le nom du modèle et la clé d'API. Le SDK officiel openai fonctionne donc avec Groq, OpenRouter, GitHub Models, Together, Mistral et bien d'autres.

Tableau comparatif des API IA gratuites

Groq — l'inference la plus rapide

Groq exécute les modèles open source (Llama 3.3, DeepSeek, Qwen, GPT-OSS) sur des puces LPU dédiées, ce qui en fait le fournisseur le plus rapide du marché — souvent plusieurs centaines de tokens par seconde. La clé gratuite s'obtient sur console.groq.com sans carte bancaire. L'endpoint est compatible OpenAI.

// groq-exemple.js — installation : npm install openai
import 'dotenv/config';
import OpenAI from 'openai';

// On réutilise le SDK OpenAI en pointant baseURL vers Groq
const groq = new OpenAI({
  apiKey: process.env.GROQ_API_KEY,            // clé gratuite depuis console.groq.com
  baseURL: 'https://api.groq.com/openai/v1',   // endpoint compatible OpenAI
});

async function poserUneQuestion(question) {
  const completion = await groq.chat.completions.create({
    model: 'llama-3.3-70b-versatile',          // modèle gratuit, très performant
    messages: [
      { role: 'system', content: 'Tu es un assistant concis qui répond en français.' },
      { role: 'user', content: question },     // la question de l'utilisateur
    ],
    temperature: 0.3,                          // réponses plus déterministes
  });

  // On retourne uniquement le texte du premier choix
  return completion.choices[0].message.content;
}

// Appel et affichage du résultat
const reponse = await poserUneQuestion('Explique le principe des LPU en une phrase.');
console.log(reponse);

Google Gemini — via AI Studio

Google AI Studio délivre une clé Gemini gratuite en quelques secondes, sans carte bancaire. Le tier gratuit de gemini-2.5-flash et gemini-2.0-flash est l'un des plus généreux du marché et inclut le multimodal (texte, image, audio). On utilise le SDK officiel @google/genai.

// gemini-exemple.js — installation : npm install @google/genai
import 'dotenv/config';
import { GoogleGenAI } from '@google/genai';

// La clé gratuite provient de aistudio.google.com/apikey
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

async function resumerTexte(texte) {
  const reponse = await ai.models.generateContent({
    model: 'gemini-2.5-flash',                 // modèle rapide du tier gratuit
    contents: `Résume ce texte en 2 phrases :\n\n${texte}`,
  });

  // .text contient la réponse générée
  return reponse.text;
}

const resume = await resumerTexte(
  'Les API IA gratuites permettent de prototyper sans budget. ' +
  'Elles imposent des quotas quotidiens mais suffisent pour la plupart des side-projects.'
);
console.log(resume);

Variante en REST pur (sans SDK), pratique côté serverless ou dans un environnement minimaliste :

// gemini-rest.js — aucune dépendance, fetch natif (Node 18+)
const cle = process.env.GEMINI_API_KEY;
const modele = 'gemini-2.5-flash';
const url = `https://generativelanguage.googleapis.com/v1beta/models/${modele}:generateContent?key=${cle}`;

const reponse = await fetch(url, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  // Structure de prompt propre à l'API Gemini
  body: JSON.stringify({
    contents: [{ parts: [{ text: 'Donne 3 idées de noms pour une app de todo IA.' }] }],
  }),
});

const data = await reponse.json();
// Le texte se trouve profond dans la structure de réponse
console.log(data.candidates[0].content.parts[0].text);

OpenRouter — l'agregateur de modeles gratuits

OpenRouter est une passerelle unique vers des centaines de modèles. Son atout : une liste de modèles totalement gratuits, identifiables par le suffixe :free (par exemple meta-llama/llama-3.3-70b-instruct:free). Une seule clé donne accès à tous ces modèles via un endpoint compatible OpenAI.

// openrouter-exemple.js — installation : npm install openai
import 'dotenv/config';
import OpenAI from 'openai';

const openrouter = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,          // clé depuis openrouter.ai/keys
  baseURL: 'https://openrouter.ai/api/v1',         // endpoint compatible OpenAI
  defaultHeaders: {
    'HTTP-Referer': 'https://angularforall.com',   // optionnel : attribution
    'X-Title': 'AngularForAll Demo',               // optionnel : nom de l'app
  },
});

async function genererCode(consigne) {
  const completion = await openrouter.chat.completions.create({
    // Le suffixe :free garantit l'utilisation du quota gratuit
    model: 'meta-llama/llama-3.3-70b-instruct:free',
    messages: [{ role: 'user', content: consigne }],
  });
  return completion.choices[0].message.content;
}

const code = await genererCode('Écris une fonction JS qui inverse une chaîne.');
console.log(code);

GitHub Models — gratuit pour les devs

GitHub Models met à disposition gratuitement des modèles de pointe (GPT-4o-mini, Llama 3.3, Phi, Mistral) pour tout compte GitHub. L'authentification se fait avec un Personal Access Token classique — aucune nouvelle inscription. L'endpoint est compatible OpenAI, idéal pour expérimenter avant de passer à un déploiement Azure.

// github-models-exemple.js — installation : npm install openai
import 'dotenv/config';
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.GITHUB_TOKEN,                 // PAT GitHub (scope : models)
  baseURL: 'https://models.github.ai/inference',    // endpoint GitHub Models
});

async function classifierSentiment(avis) {
  const completion = await client.chat.completions.create({
    model: 'openai/gpt-4o-mini',                     // modèle gratuit, rapide
    messages: [
      { role: 'system', content: 'Réponds uniquement par : positif, neutre ou négatif.' },
      { role: 'user', content: avis },
    ],
    temperature: 0,                                  // classification déterministe
  });
  return completion.choices[0].message.content.trim();
}

const sentiment = await classifierSentiment('Le produit est arrivé cassé, très déçu.');
console.log(sentiment); // → négatif

Mistral AI — le champion europeen

Mistral propose un tier gratuit « Experiment » sur sa plateforme (console.mistral.ai). Les modèles mistral-small-latest et open-mistral-nemo y sont accessibles gratuitement, avec un SDK officiel dédié et un endpoint compatible OpenAI. Atout RGPD : hébergement européen.

// mistral-exemple.js — installation : npm install @mistralai/mistralai
import 'dotenv/config';
import { Mistral } from '@mistralai/mistralai';

const mistral = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

async function traduireEnAnglais(texte) {
  const reponse = await mistral.chat.complete({
    model: 'mistral-small-latest',             // modèle du tier gratuit
    messages: [
      { role: 'system', content: 'Traduis fidèlement en anglais, sans commentaire.' },
      { role: 'user', content: texte },
    ],
  });
  return reponse.choices[0].message.content;
}

const traduction = await traduireEnAnglais('Les API gratuites accélèrent le prototypage.');
console.log(traduction);

Hugging Face — des milliers de modeles

Hugging Face donne accès, via ses Inference Providers, à des milliers de modèles open source en chat-completion, embeddings, classification, image ou audio. Le compte gratuit inclut des crédits mensuels. On utilise le client officiel @huggingface/inference.

// huggingface-exemple.js — installation : npm install @huggingface/inference
import 'dotenv/config';
import { InferenceClient } from '@huggingface/inference';

// Token gratuit depuis huggingface.co/settings/tokens
const hf = new InferenceClient(process.env.HF_TOKEN);

async function discuter(question) {
  const reponse = await hf.chatCompletion({
    model: 'meta-llama/Llama-3.3-70B-Instruct', // modèle open accessible au tier gratuit
    messages: [{ role: 'user', content: question }],
    max_tokens: 200,                            // borne la consommation de crédits
  });
  return reponse.choices[0].message.content;
}

const texte = await discuter('Cite 3 cas d’usage d’un modèle open source.');
console.log(texte);

Hugging Face brille aussi pour les embeddings (utiles en RAG), sans dépendre d'un LLM payant :

// hf-embeddings.js — vecteurs pour la recherche sémantique
import { InferenceClient } from '@huggingface/inference';
const hf = new InferenceClient(process.env.HF_TOKEN);

const vecteur = await hf.featureExtraction({
  model: 'sentence-transformers/all-MiniLM-L6-v2', // modèle d'embeddings léger
  inputs: 'Les API IA gratuites sont parfaites pour prototyper.',
});

console.log(vecteur.length); // → 384 dimensions, à stocker en base vectorielle

Cohere — RAG et embeddings

Cohere délivre des clés d'essai gratuites (rate-limitées) idéales pour le RAG d'entreprise : ses modèles Command excellent en génération ancrée sur des documents, et ses endpoints Embed et Rerank sont parmi les meilleurs pour la recherche. Le SDK officiel est cohere-ai.

// cohere-exemple.js — installation : npm install cohere-ai
import 'dotenv/config';
import { CohereClientV2 } from 'cohere-ai';

// Clé d'essai gratuite depuis dashboard.cohere.com/api-keys
const cohere = new CohereClientV2({ token: process.env.COHERE_API_KEY });

async function repondre(question) {
  const reponse = await cohere.chat({
    model: 'command-r-08-2024',                 // modèle Command du tier gratuit
    messages: [{ role: 'user', content: question }],
  });
  // La réponse texte se trouve dans message.content[0].text
  return reponse.message.content[0].text;
}

const texte = await repondre('Qu’est-ce que le re-ranking en recherche sémantique ?');
console.log(texte);

Cloudflare Workers AI — l'IA a la peripherie

Cloudflare Workers AI exécute des modèles open source sur son réseau mondial, avec une allocation quotidienne gratuite (mesurée en « neurons »). Idéal si votre back-end vit déjà sur Cloudflare, mais l'API REST est appelable depuis n'importe où avec un token et l'ID de compte.

// cloudflare-exemple.js — fetch natif, aucune dépendance
const compte = process.env.CF_ACCOUNT_ID;       // ID de compte Cloudflare
const token = process.env.CF_API_TOKEN;         // token avec permission Workers AI
const modele = '@cf/meta/llama-3.1-8b-instruct'; // modèle gratuit

const url = `https://api.cloudflare.com/client/v4/accounts/${compte}/ai/run/${modele}`;

const reponse = await fetch(url, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,           // authentification par token
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    messages: [{ role: 'user', content: 'Donne une astuce de performance web.' }],
  }),
});

const data = await reponse.json();
// La sortie texte se trouve dans result.response
console.log(data.result.response);

Together AI & AI/ML API

Deux agrégateurs supplémentaires, tous deux compatibles OpenAI, complètent la liste. Together AI offre des crédits à l'inscription et héberge une vaste bibliothèque de modèles open source. AI/ML API propose un tier gratuit donnant accès à des centaines de modèles via une seule clé.

// together-exemple.js — installation : npm install openai
import 'dotenv/config';
import OpenAI from 'openai';

const together = new OpenAI({
  apiKey: process.env.TOGETHER_API_KEY,                 // clé depuis api.together.xyz
  baseURL: 'https://api.together.xyz/v1',               // endpoint compatible OpenAI
});

const completion = await together.chat.completions.create({
  model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo-Free', // modèle gratuit Together
  messages: [{ role: 'user', content: 'Liste 3 frameworks JS en 2026.' }],
});
console.log(completion.choices[0].message.content);

Le même code fonctionne pour AI/ML API : il suffit de changer baseURL et la clé. C'est tout l'intérêt de la compatibilité OpenAI.

// aimlapi-exemple.js — réutilise le SDK openai
import OpenAI from 'openai';

const aiml = new OpenAI({
  apiKey: process.env.AIMLAPI_KEY,            // clé du tier gratuit aimlapi.com
  baseURL: 'https://api.aimlapi.com/v1',      // endpoint compatible OpenAI
});

const res = await aiml.chat.completions.create({
  model: 'gpt-4o-mini',                       // un des nombreux modèles disponibles
  messages: [{ role: 'user', content: 'Bonjour, qui es-tu ?' }],
});
console.log(res.choices[0].message.content);

Ollama — 100% local et gratuit

Quand la confidentialité prime ou que vous voulez un quota vraiment illimité, Ollama fait tourner les modèles sur votre propre machine — zéro clé, zéro coût, zéro envoi de données vers le cloud. Après ollama pull llama3.2, un serveur local écoute sur le port 11434 avec, là encore, une API compatible OpenAI.

// ollama-exemple.js — Ollama doit tourner en local (ollama serve)
import OpenAI from 'openai';

const ollama = new OpenAI({
  apiKey: 'ollama',                            // valeur factice : aucune clé requise
  baseURL: 'http://localhost:11434/v1',        // serveur Ollama local
});

async function chatLocal(question) {
  const completion = await ollama.chat.completions.create({
    model: 'llama3.2',                         // modèle téléchargé via ollama pull
    messages: [{ role: 'user', content: question }],
  });
  return completion.choices[0].message.content;
}

const reponse = await chatLocal('Pourquoi exécuter un LLM en local ?');
console.log(reponse);

Pattern : fallback multi-fournisseur

La vraie force des API gratuites apparaît quand on les cumule. En cas d'erreur 429 (quota dépassé), on bascule automatiquement vers le fournisseur suivant. Comme la plupart sont compatibles OpenAI, un simple tableau de configurations suffit.

// ai-fallback.js — bascule automatique entre fournisseurs gratuits
import 'dotenv/config';
import OpenAI from 'openai';

// Liste ordonnée des fournisseurs gratuits compatibles OpenAI
const fournisseurs = [
  { nom: 'Groq',       baseURL: 'https://api.groq.com/openai/v1', cle: process.env.GROQ_API_KEY,       model: 'llama-3.3-70b-versatile' },
  { nom: 'OpenRouter', baseURL: 'https://openrouter.ai/api/v1',   cle: process.env.OPENROUTER_API_KEY, model: 'meta-llama/llama-3.3-70b-instruct:free' },
  { nom: 'GitHub',     baseURL: 'https://models.github.ai/inference', cle: process.env.GITHUB_TOKEN,   model: 'openai/gpt-4o-mini' },
];

async function chatAvecFallback(messages) {
  // On essaie chaque fournisseur dans l'ordre jusqu'au premier qui répond
  for (const f of fournisseurs) {
    if (!f.cle) continue;                       // ignore les fournisseurs non configurés
    try {
      const client = new OpenAI({ apiKey: f.cle, baseURL: f.baseURL });
      const completion = await client.chat.completions.create({
        model: f.model,
        messages,
      });
      console.log(`Réponse fournie par : ${f.nom}`);
      return completion.choices[0].message.content;
    } catch (err) {
      // 429 = quota dépassé : on passe au fournisseur suivant
      if (err.status === 429) {
        console.warn(`${f.nom} saturé (429), bascule en cours…`);
        continue;
      }
      throw err;                                // autre erreur : on remonte l'exception
    }
  }
  throw new Error('Tous les fournisseurs gratuits sont indisponibles.');
}

const texte = await chatAvecFallback([
  { role: 'user', content: 'Résume les avantages des API IA gratuites.' },
]);
console.log(texte);

Conclusion

En 2026, démarrer un projet d'IA générative ne nécessite plus aucun budget. Groq pour la vitesse, Gemini pour le multimodal généreux, OpenRouter et GitHub Models pour la variété, Mistral pour l'hébergement européen, Hugging Face et Cohere pour le RAG et les embeddings, Cloudflare pour l'edge, et Ollama pour le 100% local : chacun couvre un besoin précis, et tous offrent une porte d'entrée gratuite.

Grâce à la compatibilité OpenAI quasi universelle, passer de l'un à l'autre — ou les combiner dans un fallback — ne demande que quelques lignes. Commencez par le fournisseur qui correspond à votre cas d'usage, mesurez vos quotas réels, puis ajoutez une stratégie de bascule pour tenir la charge sans dépenser un centime. Quand le trafic décolle, le passage au tier payant se fera sur le même code.