Cómo usar claves de API de Gemini

Para usar la API de Gemini, necesitas una clave de API. Puedes crear una clave de forma gratuita con unos pocos clics en Google AI Studio.

Una vez que tengas una clave de API, tendrás las siguientes opciones para conectarte a la API de Gemini:

• Cómo establecer tu clave de API como una variable de entorno
• Cómo proporcionar tu clave de API de forma explícita

Para las pruebas iniciales, puedes codificar de forma rígida una clave de API, pero esto solo debe ser temporal, ya que no es seguro. Puedes encontrar ejemplos para codificar de forma rígida la clave de API en la sección Cómo proporcionar la clave de API de forma explícita.

Cómo configurar la clave de API como una variable de entorno

Si configuras la variable de entorno GEMINI_API_KEY o GOOGLE_API_KEY, el cliente seleccionará automáticamente la clave de API cuando uses una de las bibliotecas de la API de Gemini. Te recomendamos que configures solo una de esas variables, pero, si configuras ambas, GOOGLE_API_KEY tiene prioridad.

Si usas la API de REST o JavaScript en el navegador, deberás proporcionar la clave de API de forma explícita.

A continuación, se explica cómo puedes establecer tu clave de API de forma local como la variable de entorno GEMINI_API_KEY con diferentes sistemas operativos.

~/.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

Cómo proporcionar la clave de API de forma explícita

En algunos casos, es posible que quieras proporcionar una clave de API de forma explícita. Por ejemplo:

• Estás realizando una llamada a la API simple y prefieres codificar de forma rígida la clave de API.
• Quieres tener un control explícito sin tener que depender del descubrimiento automático de las variables de entorno por parte de las bibliotecas de la API de Gemini.
• Estás usando un entorno en el que no se admiten variables de entorno (p. ej., la Web) o estás realizando llamadas a la API de REST.

A continuación, se incluyen ejemplos de cómo puedes proporcionar una clave de API de forma explícita:

from google import genai

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

response = client.models.generate_content(
    model="gemini-2.5-flash", contents="Explain how AI works in a few words"
)
print(response.text)

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

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

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: "Explain how AI works in a few words",
  });
  console.log(response.text);
}

main();

package main

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

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)
    }

    result, err := client.Models.GenerateContent(
        ctx,
        "gemini-2.5-flash",
        genai.Text("Explain how AI works in a few words"),
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result.Text())
}

package com.example;

import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;

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

    GenerateContentResponse response =
        client.models.generateContent(
            "gemini-2.5-flash",
            "Explain how AI works in a few words",
            null);

    System.out.println(response.text());
  }
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -X POST \
  -d '{
    "contents": [
      {
        "parts": [
          {
            "text": "Explain how AI works in a few words"
          }
        ]
      }
    ]
  }'

Protege tu clave de API

Trata tu clave de API de Gemini como una contraseña. Si se ve comprometida, otras personas pueden usar la cuota de tu proyecto, incurrir en cargos (si la facturación está habilitada) y acceder a tus datos privados, como los archivos.

Reglas de seguridad críticas

• Nunca confirmes las claves de API en el control de código fuente. No registres tu clave de API en sistemas de control de versión como Git.

• Nunca expongas las claves de API en el cliente. No uses tu clave de API directamente en apps web o para dispositivos móviles en producción. Las claves en el código del cliente (incluidas nuestras bibliotecas de JavaScript/TypeScript y las llamadas a REST) se pueden extraer.

Prácticas recomendadas

• Usa llamadas del servidor con claves de API. La forma más segura de usar tu clave de API es llamar a la API de Gemini desde una aplicación del servidor en la que la clave se pueda mantener confidencial.

• Usa tokens efímeros para el acceso del cliente (solo para la API de Live): Para el acceso directo del cliente a la API de Live, puedes usar tokens efímeros. Tienen riesgos de seguridad más bajos y pueden ser adecuados para el uso en producción. Consulta la guía de tokens efímeros para obtener más información.

• Considera agregar restricciones a tu clave: Puedes limitar los permisos de una clave agregando restricciones de clave de API. Esto minimiza el daño potencial si alguna vez se filtra la clave.

Para conocer algunas prácticas recomendadas generales, también puedes consultar este artículo de ayuda.