Comment utiliser Google Gemini API en 2026 (débutants)

Introduction

L'API Google Gemini représente la nouvelle génération d'IA générative de Google, accessible via des modèles comme Gemini 1.5 Flash ou Pro. En 2026, elle est incontournable pour les développeurs souhaitant ajouter des fonctionnalités intelligentes à leurs apps : génération de texte, conversations naturelles, analyse d'images ou même vidéo. Contrairement aux APIs fermées, Gemini offre un SDK officiel simple, gratuit jusqu'à un certain quota, et scalable.

Ce tutoriel débutant vous guide pas à pas pour créer une application Node.js qui interagit avec Gemini. Vous apprendrez à obtenir une clé API gratuite, installer le SDK, générer du texte simple, gérer des conversations et explorer le multimodal (texte + image). Chaque exemple est complet et fonctionnel, prêt à copier-coller. À la fin, vous maîtriserez les bases pour booster vos projets web, bots ou outils internes. Temps estimé : 15 minutes pour un premier appel réussi.

Prérequis

Node.js 20+ installé
Compte Google gratuit
Connaissances basiques en JavaScript (promesses/async)
Éditeur de code (VS Code recommandé)
Terminal pour exécuter les commandes

Obtenir votre clé API Gemini

terminal-setup.sh

echo "Créez un compte sur https://aistudio.google.com/"
echo "Cliquez sur 'Get API key' > New API key"
echo "Copiez la clé et créez un fichier .env :"

cat > .env << EOF
GOOGLE_GEMINI_API_KEY=your_api_key_here
EOF

npm init -y
npm install @google/generative-ai dotenv

Cette commande initialise un projet Node.js, installe le SDK officiel @google/generative-ai et dotenv pour gérer la clé API en sécurité. Remplacez your_api_key_here par votre vraie clé obtenue sur AI Studio. Ne commitez jamais .env dans Git (ajoutez-le à .gitignore).

Comprendre la clé API et la sécurité

La clé API est gratuite pour 15 RPM (requêtes par minute) sur Gemini 1.5 Flash. Stockez-la dans .env pour éviter les fuites. Utilisez des variables d'environnement en prod (Vercel, Render). Analogie : c'est comme une clé de maison – protégez-la !

Premier appel : Génération de texte simple

generate-text.js

require('dotenv').config();
const { GoogleGenerativeAI } = require('@google/generative-ai');

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

async function generateText() {
  const prompt = 'Explique-moi l\'IA générative en 3 phrases simples.';
  const result = await model.generateContent(prompt);
  const response = await result.response;
  const text = response.text();
  console.log(text);
}

generateText().catch(console.error);

Ce script charge la clé via dotenv, initialise le modèle 'gemini-1.5-flash' (rapide et gratuit), envoie un prompt et affiche la réponse. Exécutez avec node generate-text.js. Piège : Oubliez await et vous aurez des erreurs async – toujours encapsuler en fonction async.

Anatomie d'une réponse Gemini

text() : Extrait le texte principal
response.full() : Tout (citations, sécurité)
usageMetadata : Tokens utilisés (quota)

Testez avec node generate-text.js : vous verrez une explication claire de l'IA.

Conversation multi-tour (chat)

chat-conversation.js

require('dotenv').config();
const { GoogleGenerativeAI } = require('@google/generative-ai');

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

async function chat() {
  const chat = model.startChat({
    history: [
      {
        role: 'user',
        parts: [{ text: 'Bonjour, qui es-tu ?' }]
      },
      {
        role: 'model',
        parts: [{ text: 'Je suis Gemini, un modèle IA de Google.' }]
      }
    ],
    generationConfig: { maxOutputTokens: 200 }
  });

  const result = await chat.sendMessage('Quelle est la capitale de la France ?');
  console.log(result.response.text());
}

chat().catch(console.error);

Utilisez startChat() pour un historique contextuel, idéal pour bots Telegram/Discord. generationConfig limite les tokens pour contrôler les coûts. Ajoutez safetySettings pour filtrer le contenu sensible. Exécutez et observez la mémoire conversationnelle.

Génération multimodale (texte + image)

multimodal.js

require('dotenv').config();
const { GoogleGenerativeAI } = require('@google/generative-ai');
const fs = require('fs');

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

async function analyzeImage() {
  const imagePart = {
    inlineData: {
      data: fs.readFileSync('image.jpg').toString('base64'),
      mimeType: 'image/jpeg'
    }
  };
  const result = await model.generateContent(['Décris cette image en détail.'], imagePart);
  const response = await result.response;
  console.log(response.text());
}

analyzeImage().catch(console.error);

Gemini excelle en multimodal : chargez une image locale en base64 et analysez-la. Remplacez 'image.jpg' par un vrai fichier (téléchargez-en un test). Limite : 20MB max. Parfait pour apps de vision IA comme analyse de CV ou photos produits.

Streaming pour réponses en temps réel

Pour une UX fluide (comme ChatGPT), utilisez streamGenerateContent(). Ajoutez-le à vos scripts pour voir les tokens arriver progressivement.

Streaming de génération

streaming.js

require('dotenv').config();
const { GoogleGenerativeAI } = require('@google/generative-ai');

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

async function streamContent() {
  const prompt = 'Rédige un poème sur Node.js en streaming.';
  const stream = await model.streamGenerateContent(prompt);
  let fullText = '';
  for await (const chunk of stream.stream) {
    const text = chunk.value.text();
    process.stdout.write(text);
    fullText += text;
  }
  console.log('\n\nTexte complet :', fullText);
}

streamContent().catch(console.error);

Boucle for await itère sur les chunks pour un affichage live. Idéal pour interfaces web avec Server-Sent Events. Économise de la mémoire vs réponses complètes.

Script intégré avec Express (serveur API)

server.js

require('dotenv').config();
const express = require('express');
const { GoogleGenerativeAI } = require('@google/generative-ai');

const app = express();
app.use(express.json());
const genAI = new GoogleGenerativeAI(process.env.GOOGLE_GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

app.post('/generate', async (req, res) => {
  try {
    const { prompt } = req.body;
    const result = await model.generateContent(prompt);
    res.json({ response: result.response.text() });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => console.log('Serveur sur http://localhost:3000'));

// npm install express requis

Transformez en API REST avec Express. POST /generate avec {prompt: '...'}. Gérez les erreurs pour prod. Testez avec curl ou Postman : curl -X POST -d '{"prompt":"Hello"}' http://localhost:3000/generate.

Bonnes pratiques

Rate limiting : Implémentez un cache Redis pour éviter les quotas.
Sécurité : Activez safetySettings (BLOCK_MEDIUM_AND_ABOVE) pour filtrer.
Tokens : Surveillez usageMetadata et optimisez les prompts courts.
Modèles : Flash pour vitesse, Pro pour complexité.
Erreurs : Toujours try/catch sur les appels async.

Erreurs courantes à éviter

Clé invalide : Vérifiez l'API key sur AI Studio (pas de quotas dépassés).
Pas d'await : Les promesses rejettent silencieusement sans async.
Fichier image trop gros : <20MB, compressez avant base64.
Oubli dotenv : undefined pour API_KEY → 401 Unauthorized.

Pour aller plus loin

Maîtrisez les embeddings pour recherche sémantique, intégrez à Next.js ou React. Découvrez nos formations IA avancées Learni. Docs officielles : ai.google.dev. Exemples GitHub : google/generative-ai-node.

Comment utiliser l'API Google Gemini en 2026