Utiliser des clés API Gemini

Pour utiliser l'API Gemini, vous devez authentifier vos requêtes. Vous pouvez vous authentifier à l'aide d'une clé API standard ou d'autorisation.

Créer ou afficher une clé API Gemini

Types de clés API : standard ou d'autorisation

Les clés API permettent d'accéder à l'API Gemini, mais leurs caractéristiques de sécurité diffèrent. Pour améliorer la sécurité, l'API Gemini passe des clés API standard aux clés d'autorisation :

• Les clés API standard associent les requêtes à un projet Google Cloud à des fins de facturation et de quota. Les clés standard n'identifient pas un appelant, ce qui limite la granularité des autorisations et du contrôle d'accès qu'elles peuvent prendre en charge.
• Les clés d'autorisation sont directement liées à un compte de service Google Cloud. Lorsque vous utilisez une clé d'autorisation, vos requêtes sont traitées sous l'identité de ce compte de service lié, ce qui permet un contrôle d'accès précis. Les clés d'autorisation sont limitées à l'API Generative Language (API Gemini) par défaut et permettent d'appliquer rapidement les clés divulguées, ce qui arrête rapidement l'utilisation des clés divulguées détectées par nos systèmes.

Pour garantir une utilisation sécurisée, l'API Gemini passera des clés standard aux clés d'autorisation :

• Clés d'autorisation par défaut : toutes les nouvelles clés API créées dans Google AI Studio sont automatiquement créées en tant que clés d'autorisation.
• Clés sans restriction refusées : l'API Gemini refuse les requêtes provenant de clés standard sans restriction. Les clés API standard auxquelles des restrictions explicites sont appliquées continuent de fonctionner. Cette restriction empêche l'utilisation non autorisée de clés qui pourraient être partagées publiquement ou liées à d'autres services.
• En septembre 2026 : l'API Gemini refusera les requêtes provenant de clés standard. Vous devez migrer vers des clés d'autorisation avant cette date pour éviter toute interruption de service. Veillez à migrer vers des clés d'autorisation avant septembre 2026.

Gérer les clés API dans Google AI Studio

Vous pouvez gérer vos projets et vos clés directement dans Google AI Studio.

Projets Google Cloud

Chaque clé API Gemini est associée à un projet Google Cloud. Les projets Google Cloud gèrent la facturation, les collaborateurs et les autorisations. Google AI Studio fournit une interface légère pour accéder à ces projets.

• Projet par défaut : si vous êtes un nouvel utilisateur, Google AI Studio crée automatiquement un projet Google Cloud et une clé API par défaut après que vous avez accepté les conditions d'utilisation. Vous pouvez renommer ce projet en accédant à la vue Projets de votre tableau de bord.
• Projets existants : si vous possédez déjà un compte Google Cloud, AI Studio ne crée pas de projet par défaut. Vous devez plutôt importer vos projets existants.

Importer des projets

Par défaut, Google AI Studio n'affiche pas tous vos projets Google Cloud. Vous devez importer les projets que vous souhaitez utiliser :

1. Accédez à Google AI Studio.
2. Ouvrez le tableau de bord dans le panneau de gauche, puis sélectionnez Projets.
3. Cliquez sur le bouton Importer des projets.
4. Recherchez et sélectionnez le projet Google Cloud que vous souhaitez importer, puis cliquez sur Importer.
5. Une fois l'importation terminée, accédez à la page Clés API du tableau de bord pour créer une clé dans ce projet.

Résoudre les problèmes d'autorisations de création de clés

Si le bouton Créer une clé API n'est pas disponible et affiche le message : "Vous ne disposez pas des autorisations nécessaires pour créer une clé dans ce projet", vous ne disposez pas des autorisations IAM requises.

Demandez à l'administrateur de votre projet ou de votre organisation Google Cloud de vous accorder un rôle contenant les autorisations suivantes (par exemple, Éditeur de projet) :

• resourcemanager.projects.get : permet à AI Studio de vérifier le projet.
• apikeys.keys.create : permet la génération de clés.
• serviceusage.services.enable: garantit que l'API Generative Language est activée.
• iam.serviceAccounts.create : obligatoire pour créer le compte de service lié.
• iam.serviceAccountApiKeyBindings.create: lie le compte de service à la clé API.

Si vous ne parvenez pas à obtenir un accès administrateur, vous pouvez créer un projet Google Cloud qui n'est pas associé à une organisation pour générer vos clés.

Configurer votre environnement

Une fois que vous disposez d'une clé, configurez votre environnement pour l'utiliser de manière sécurisée dans vos applications.

Option 1 : Utiliser des variables d'environnement (recommandé)

Définissez la variable d'environnement GEMINI_API_KEY ou GOOGLE_API_KEY. Les bibliothèques clientes de l'API Gemini détectent et utilisent automatiquement ces variables. Si les deux sont définies, GOOGLE_API_KEY est prioritaire.

Sélectionnez votre système d'exploitation pour définir la variable :

~/.bashrc

touch ~/.bashrc && open ~/.bashrc

export GEMINI_API_KEY=<YOUR_API_KEY_HERE>

source ~/.bashrc

~/.zshrc

touch ~/.zshrc && open ~/.zshrc

export GEMINI_API_KEY=<YOUR_API_KEY_HERE>

source ~/.zshrc

Option 2 : Fournir explicitement la clé API dans le code

Vous pouvez transmettre explicitement la clé API lors de l'initialisation du client. Ne le faites que si vous ne pouvez pas utiliser de variables d'environnement.

from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain how AI works in a few words"
)
print(interaction.output_text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "YOUR_API_KEY" });

async function main() {
  const interaction = await ai.interactions.create({
    model: "gemini-3.5-flash",
    input: "Explain how AI works in a few words",
  });
  console.log(interaction.output_text);
}

main();

package main

import (
    "context"
    "fmt"
    "log"
    "google.golang.org/genai"
    "google.golang.org/genai/interactions"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
        APIKey:  "YOUR_API_KEY",
        Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
        log.Fatal(err)
    }

    interaction, err := client.Interactions.NewModel(ctx, interactions.NewModelParams{
        Model: "gemini-3.5-flash",
        Input: interactions.Input{
            String: "Explain how AI works in a few words",
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, step := range interaction.Steps {
        if step.ModelOutput != nil {
            for _, content := range step.ModelOutput.Content {
                if content.Text != nil {
                    fmt.Println(content.Text.Text)
                }
            }
        }
    }
}

package com.example;

import com.google.genai.Client;
import com.google.genai.interactions.models.interactions.CreateModelInteractionParams;
import com.google.genai.interactions.models.interactions.Interaction;

public class GenerateTextFromTextInput {
  public static void main(String[] args) {
    Client client = Client.builder().apiKey("YOUR_API_KEY").build();

    CreateModelInteractionParams params =
        CreateModelInteractionParams.builder()
            .input("Explain how AI works in a few words")
            .model("gemini-3.5-flash")
            .build();

    Interaction interaction = client.interactions.create(params);

    interaction.steps().forEach(step -> {
      if (step.isModelOutput()) {
        step.asModelOutput().content().ifPresent(contents -> {
          contents.forEach(content -> {
            content.text().ifPresent(text -> System.out.println(text.text()));
          });
        });
      }
    });
  }
}

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -X POST \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Explain how AI works in a few words"
  }'

Sécurité et gestion des secrets

Traitez votre clé API Gemini comme un mot de passe. Si elle est compromise, d'autres personnes peuvent consommer le quota de votre projet, entraîner des frais de facturation inattendus et accéder à des ressources privées.

Règles de sécurité critiques

• Gardez vos clés confidentielles : n'enregistrez jamais de clés API dans des systèmes de contrôle des sources tels que Git.
• N'exposez jamais de clés côté client en production : ne codez pas en dur les clés API directement dans les applications Web ou mobiles. Les clés compilées dans le code côté client peuvent être extraites par les utilisateurs. Pour sécuriser les applications côté client, exécutez un serveur proxy de backend pour effectuer les appels d'API réels.

Bonnes pratiques concernant la gestion des secrets

• Variables d'environnement : lisez les clés à partir de variables d'environnement plutôt que de fichiers de configuration.
• Secret Manager : pour la production, stockez vos clés dans un magasin de secrets sécurisé tel que Google Cloud Secret Manager.
• Alertes de facturation : configurez des alertes de facturation dans la console Google Cloud pour être averti en cas de pic d'utilisation ou de coûts.

Checklist de réponse en cas de fuite

Si vous pensez que votre clé API a été divulguée :

1. Générez une nouvelle clé : créez une clé de remplacement dans Google AI Studio ou Cloud Console.
2. Mettez à jour votre application : déployez votre code à l'aide de la nouvelle clé.
3. Désactivez ou supprimez la clé compromise : désactivez la clé divulguée dans Cloud Console une fois la nouvelle clé validée. Ne supprimez pas l'ancienne clé tant que la nouvelle n'est pas entièrement active pour éviter les temps d'arrêt de l'application.
4. Auditez l'utilisation : vérifiez les journaux de facturation et l'utilisation de l'API dans la console Google Cloud pour identifier toute activité non autorisée.

Restreindre et sécuriser vos clés

L'ajout de restrictions à vos clés API minimise les dommages potentiels si une clé est compromise.

Appliquer des restrictions d'origine des requêtes

Les restrictions d'origine limitent les adresses IP, les sites Web ou les applications qui peuvent utiliser votre clé.

1. Accédez à la page "Identifiants" de la console Google Cloud.
2. Sélectionnez votre projet, puis cliquez sur le nom de la clé API que vous souhaitez restreindre.
3. Sous Restrictions liées aux applications, sélectionnez Adresses IP (ou le type de restriction approprié pour votre environnement).
4. Spécifiez les adresses IP ou les plages autorisées, puis cliquez sur Enregistrer.

Sécuriser les clés API standard sans restriction

Pour continuer à utiliser l'API Gemini, vous devez sécuriser toutes les clés sans restriction.

Méthode A : Limiter la clé à l'API Gemini uniquement (AI Studio)

Si vous n'utilisez la clé que pour l'API Gemini, sécurisez-la directement dans AI Studio :

1. Sur la page Clés API de Google AI Studio, recherchez les clés marquées du libellé Sans restriction.
2. Pointez sur le libellé et cliquez sur Ajouter des restrictions dans la boîte de dialogue.
3. Sélectionnez Restreindre à l'API Gemini uniquement.
4. Cliquez sur Restreindre la clé pour confirmer.

Méthode B : Limiter la clé à d'autres services (console Google Cloud)

Si la clé est partagée avec d'autres API Google (non recommandé), limitez-la dans Cloud Console. Remarque : Les requêtes de l'API Gemini utilisant cette clé échoueront une fois ces restrictions appliquées.

1. Accédez à la page "Identifiants" de la console Google Cloud.
2. Sélectionnez le projet et la clé API.
3. Sous Restrictions liées à l'API, utilisez le menu déroulant Sélectionner des restrictions d'API pour sélectionner les API auxquelles vous souhaitez que cette clé accède. Ne sélectionnez pas l'API Generative Language.
4. Cliquez sur Enregistrer. Créez une clé distincte et limitée dans AI Studio pour continuer à utiliser l'API Gemini.

Clés inactives bloquées

À partir du 7 mai 2026, l'API Gemini bloquera les clés API sans restriction qui sont inactives depuis une période prolongée. Ces clés affichent un tag Bloqué dans AI Studio. Vous devez générer une nouvelle clé ou utiliser une clé limitée existante pour continuer.

Migrer vers une clé d'autorisation

Suivez ces étapes pour créer une clé API d'autorisation et mettre à jour vos applications :

1. Accédez à la page "Clés API" d'AI Studio.
2. Cochez la colonne Type de clé pour identifier les clés listées comme Standard.
3. Cliquez sur Créer une clé API pour générer une clé. Toutes les nouvelles clés créées dans AI Studio sont automatiquement créées en tant que clés d'autorisation.
4. Copiez la nouvelle clé API d'autorisation.
5. Mettez à jour le code de votre application, les variables d'environnement et toutes les configurations de déploiement pour utiliser la nouvelle clé API d'autorisation.
6. Testez votre application pour vérifier qu'elle fonctionne correctement avec la nouvelle clé.
7. Une fois la validation effectuée, supprimez ou révoquez votre ancienne clé de trafic pour éviter toute utilisation abusive.

Limites

Google AI Studio impose les limites suivantes en matière de gestion des projets et des clés :

• Vous pouvez créer au maximum 10 projets à la fois à partir de la page Projets de Google AI Studio.
• Les pages Clés API et Projets affichent au maximum 100 clés et 50 projets.
• Seules les clés API sans restriction ou limitées spécifiquement à l'API Generative Language (API Gemini) sont affichées.

Pour une gestion avancée des projets ou pour modifier des clés avec d'autres restrictions, utilisez la page "Identifiants" de la console Google Cloud.