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 : clés standards et clés d'autorisation

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

• Clés API standards : associent les requêtes à un projet Google Cloud à des fins de facturation et de quota. Les clés standards n'identifient pas l'appelant, ce qui limite la précision des autorisations et du contrôle des accès qu'elles peuvent prendre en charge.
• Clés d'autorisation (auth) : liées directement à 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 associé, ce qui permet un contrôle des accès précis. Les clés d'autorisation sont limitées par défaut à l'API Generative Language (API Gemini) et permettent d'appliquer rapidement des mesures d'application en cas de fuite de clé, ce qui interrompt 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 standards aux clés d'authentification :

• Clés d'authentification par défaut : à partir du 28 mai 2026, toutes les nouvelles clés API créées dans Google AI Studio seront automatiquement créées en tant que clés d'authentification.
• Rejet des clés sans restriction : l'API Gemini rejette les requêtes provenant de clés standards sans restriction. Les clés API standards 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 associées à d'autres services.

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 n'avez pas l'autorisation de créer une clé dans ce projet", cela signifie que vous ne disposez pas des autorisations IAM requises.

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

• resourcemanager.projects.get : permet à AI Studio de valider le projet.
• apikeys.keys.create : permet de générer des clés.
• serviceusage.services.enable : s'assure que l'API Generative Language est activée.
• iam.serviceAccounts.create : requis pour créer le compte de service associé.
• 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.

Clés inconnues sur la page "Utilisation"

La page "Utilisation" de Google AI Studio regroupe les requêtes qu'elle ne peut pas associer à une clé API nommée dans le projet sous (clés inconnues). Cela inclut les clés supprimées il y a plus de 30 jours, les clés sans nom à afficher et les requêtes effectuées avec d'autres identifiants, comme OAuth.

Créer des clés dans la console Google Cloud

Google AI Studio n'affiche que les clés qui ne sont pas restreintes ou qui sont limitées à l'API Gemini. Si vous ne pouvez pas utiliser AI Studio ou si vous souhaitez gérer toutes vos clés API au même endroit, suivez la documentation Cloud sur la création d'une clé API. Pour créer une clé API Gemini, vous devez la lier à un compte de service.

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, la règle GOOGLE_API_KEY prévaut.

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 la clé API explicitement lors de l'initialisation du client. Ne procédez ainsi 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.8-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.8-flash",
    input: "Explain how AI works in a few words",
  });
  console.log(interaction.output_text);
}

main();

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = Client.builder().apiKey("YOUR_API_KEY").build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Explain how AI works in a few sentences."))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput("Explain how AI works in a few sentences."),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

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.8-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

• Préservez la confidentialité des clés : n'enregistrez jamais de clés API dans des systèmes de contrôle de code source comme Git.
• N'exposez jamais les 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 pour 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 aux fuites

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

1. Générer une nouvelle clé : créez une clé de remplacement dans Google AI Studio ou dans la console Cloud.
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 la console Cloud une fois que la nouvelle clé a été validée. Ne supprimez pas l'ancienne clé tant que la nouvelle n'est pas entièrement active, afin d'éviter l'indisponibilité de l'application.
4. Auditer l'utilisation : vérifiez les journaux de facturation et l'utilisation des 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 en cas de compromission d'une clé.

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 ou plages d'adresses IP autorisées, puis cliquez sur Enregistrer.

Sécuriser les clés API standards sans restriction

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

Méthode A : Restreindre 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 portant le libellé Sans restriction.
2. Pointez sur l'étiquette, puis 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 : Restreindre la clé pour d'autres services (console Google Cloud)

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

1. Accédez à la page des identifiants de la console Google Cloud.
2. Sélectionnez le projet et la clé API.
3. Sous Restrictions relatives aux 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 restreinte 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é restreinte existante pour continuer.

Migrer vers une clé d'authentification

Pour créer une clé API d'authentification et mettre à jour vos applications, procédez comme suit :

1. Accédez à la page Clés API AI Studio.
2. Consultez 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 nouvelle clé. Toutes les nouvelles clés créées dans AI Studio sont automatiquement créées en tant que clés d'authentification.
4. Copiez la nouvelle clé API d'authentification.
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'authentification.
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 pour la gestion des projets et des clés :

• Vous pouvez créer jusqu'à 10 projets à la fois depuis 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) s'affichent.

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