Cómo usar la API Nano Banana 2.1

Google lanzó Nano Banana 2.1 el 6 de octubre de 2026, y ya se puede llamar a través de la API de Gemini como gemini-nano-banana-2.1. Es una actualización de Nano Banana 2 (Gemini 3.1 Flash Image) con mejor calidad visual, edición estilo máscara y mayor consistencia de personajes en las interacciones. También cuesta la mitad por imagen que Nano Banana 2 en cada resolución que comparten.

Esta guía te lleva desde una terminal vacía hasta una imagen guardada, luego cubre las relaciones de aspecto, la salida 2K y 4K, la edición, los cambios en múltiples turnos, las imágenes de referencia, la fundamentación de búsqueda y el costo. Cada solicitud a continuación se puede guardar y reproducir en Apidog para que puedas comparar 2.1 con el modelo que utilizas hoy.

¿Quieres el contexto primero? Lee Qué es Nano Banana 2.1 para saber qué cambió y qué Google aún no ha publicado.

Lo que necesitas

Todos los ejemplos utilizan la API de Interacciones, que es la que usa la documentación de generación de imágenes de Google para 2.1.

Paso 1: Obtén una clave de API de Gemini

1. Abre Google AI Studio e inicia sesión.
2. Ve a Obtener clave de API y crea una clave en un proyecto de Google Cloud.
3. Activa la facturación para ese proyecto. La página de precios de Google indica que el nivel gratuito para Nano Banana 2.1 como "No disponible", por lo que las llamadas a la API requieren un proyecto de pago.
4. Exporta la clave:

export GEMINI_API_KEY="your-key-here"

Google vincula 2.1 al entorno de pruebas de AI Studio, lo cual es útil para probar prompts, pero no ha publicado cuánto puede generar una cuenta gratuita allí. Nuestra guía sobre cómo usar Nano Banana 2.1 gratis cubre esa ruta, y obtener una clave de API de Gemini explica la configuración de la clave con más detalle.

Paso 2: Genera tu primera imagen

curl

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {"type": "text", "text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"}
    ]
  }'

La respuesta es JSON. La imagen llega como datos base64 dentro de un bloque de contenido de imagen, por lo que querrás un SDK (o un script) para decodificarla.

Python

from google import genai
import base64

client = genai.Client()  # reads GEMINI_API_KEY

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
)

with open("generated_image.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

interaction.output_image devuelve el último bloque de imagen generado. Su campo data está en base64, así que decodifícalo antes de escribir el archivo.

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});

const interaction = await ai.interactions.create({
  model: "gemini-nano-banana-2.1",
  input: "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
});

const image = interaction.output_image;
if (image) {
  fs.writeFileSync("nano-banana.png", Buffer.from(image.data, "base64"));
}

Los modelos de imagen Gemini 3 "piensan" antes de dibujar. El modelo puede producir hasta dos "imágenes de pensamiento" intermedias mientras planifica la composición. No se te cobra por estas, y el "pensamiento" no se puede desactivar en la API.

Paso 3: Establece la relación de aspecto, la resolución y la salida solo de imagen

Usa response_format para controlar la salida. Establecer "type": "image" devuelve solo la imagen y omite el texto conversacional, lo que mantiene las respuestas más pequeñas y el análisis más simple.

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A product shot of a matte black coffee grinder on a marble counter",
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

Cosas a saber:

• image_size acepta 1K, 2K y 4K. Usa una K mayúscula; los valores en minúscula como 2k son rechazados.
• 2.1 no tiene un nivel de 512px. Ese pertenece a Nano Banana 2.
• Las relaciones de aspecto admitidas incluyen 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9, además de las extremas 1:4, 4:1, 1:8 y 8:1. Una imagen de 16:9 en 2K es de 2752x1536; en 4K es de 5504x3072.
• Si quieres tanto texto como una imagen, pasa una lista: response_format=[{"type": "text"}, {"type": "image"}].

Paso 4: Edita una imagen existente

Envía tu imagen como un bloque image en base64 junto a la instrucción de texto:

with open("living_room.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {"type": "text", "text": "Using the provided image of a living room, change only the blue sofa to be a vintage, brown leather chesterfield sofa. Keep the rest of the room, including the pillows on the sofa and the lighting, unchanged."},
        {"type": "image", "data": image_b64, "mime_type": "image/png"},
    ],
)

Inpainting estilo máscara sin un archivo de máscara

No hay una carga de máscara separada. Defines la máscara con palabras. La plantilla de Google:

Usando la imagen proporcionada, cambia solo el [elemento específico] a [nuevo elemento/descripción]. Mantén todo lo demás en la imagen exactamente igual, preservando el estilo, la iluminación y la composición originales.

Nombra un elemento, describe el reemplazo de forma concreta y repite lo que debe permanecer fijo. Prompts vagos como "haz que el sofá sea más bonito" invitan al modelo a redibujar toda la habitación.

Paso 5: Itera con edición de múltiples turnos

La edición de múltiples turnos es la forma recomendada por Google para refinar una imagen. Pasa el id de la interacción anterior como previous_interaction_id y envía solo el cambio que deseas:

interaction_2 = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Update this infographic to be in Spanish. Do not change any other elements of the image.",
    previous_interaction_id=interaction.id,
    response_format={"type": "image", "mime_type": "image/png", "aspect_ratio": "16:9", "image_size": "2K"},
)

A través de REST, el mismo campo va en el cuerpo: "previous_interaction_id": "<PREVIOUS_INTERACTION_ID>". Aquí es donde la consistencia mejorada de los personajes en múltiples turnos de 2.1 es importante: un personaje o producto debe permanecer reconocible a lo largo de varias rondas de ediciones.

Paso 6: Combina hasta 14 imágenes de referencia

Agrega más bloques image a la lista input. Para 2.1, Google documenta hasta 10 imágenes de objetos de alta fidelidad y hasta 4 imágenes de personajes, 14 en total:

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {"type": "text", "text": "An office group photo of these people, they are making funny faces."},
        {"type": "image", "data": person_1_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_2_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_3_b64, "mime_type": "image/png"},
    ],
    response_format={"type": "image", "aspect_ratio": "5:4", "image_size": "2K"},
)

Las imágenes de referencia son tokens de entrada, y la entrada de 2.1 cuesta tres veces más de lo que cobra Nano Banana 2. Los flujos de trabajo con muchas referencias reducen la brecha de precios, así que mide antes de cambiar.

Paso 7: Fundamenta imágenes con la Búsqueda de Google

Para imágenes que dependen de hechos actuales, como un mapa del tiempo o un evento reciente, agrega la herramienta de búsqueda:

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A detailed painting of a Timareta butterfly resting on a flower",
    tools=[{"type": "google_search", "search_types": ["web_search", "image_search"]}],
)

{"type": "google_search"} por sí solo te da búsqueda web. Agregar image_search permite que el modelo use imágenes web como contexto visual, lo que solo 2.1 y Nano Banana 2 admiten. La fundamentación no puede usar imágenes de personas del mundo real de la búsqueda. Si muestras resultados fundamentados a los usuarios, Google te exige que muestres las search_suggestions devueltas en el paso google_search_result.

Paso 8: Pruébalo en Apidog

Los scripts están bien para la generación. Para verificar que un prompt, una clave y un modelo aún funcionan, una solicitud guardada es más rápida. En Apidog:

1. Crea un entorno y agrega una variable GEMINI_API_KEY con tu clave.
2. Crea una solicitud: POST https://generativelanguage.googleapis.com/v1beta/interactions.
3. Agrega el encabezado x-goog-api-key: {{GEMINI_API_KEY}}.
4. Pega un cuerpo JSON con model, input y response_format, luego haz clic en Enviar.
5. Agrega un script post-respuesta con dos aserciones:

pm.test("status is 200", () => {
  pm.response.to.have.status(200);
});

pm.test("response contains an image block", () => {
  const steps = pm.response.json().steps || [];
  const hasImage = steps.some(s =>
    s.type === "model_output" &&
    (s.content || []).some(c => c.type === "image" && c.data)
  );
  pm.expect(hasImage).to.be.true;
});

6. Duplica la solicitud y cambia model a gemini-3.1-flash-image. Envía ambas con el mismo prompt.

Ahora tienes una comparación lado a lado de 2.1 con Nano Banana 2, con el estado, el tiempo y el tamaño de la respuesta mostrados para cada ejecución. Para una comparación de características más amplia, consulta Nano Banana 2.1 vs Nano Banana 2 vs Pro.

Lo que cuesta

Nivel de pago, según la página de precios de Google el 7 de octubre de 2026:

La salida de imagen para 2.1 es de $30 por 1M de tokens. Una imagen de 1K son 1,120 tokens, 2K son 1,680 y 4K son 2,520, de ahí provienen los precios por imagen. La salida de texto y "pensamiento" es de $7.50 por 1M. La fundamentación de búsqueda incluye 5,000 solicitudes gratuitas al mes compartidas entre los modelos Gemini 3.x, luego $14 por cada 1,000.

Ejemplo práctico: 1,000 imágenes de productos en 2K a partir de prompts de texto cortos (aproximadamente 100 tokens de entrada cada uno).

• Salida: 1,000 x $0.0504 = $50.40
• Entrada: 100,000 tokens x $1.50 / 1M = $0.15
• Total: aproximadamente $50.55, más cualquier token de texto de "pensamiento"

El mismo trabajo en Nano Banana 2 cuesta alrededor de $101. A través de la API por lotes (Batch API), el precio de 2K de 2.1 baja a $0.0252, por lo que el lado de la salida se reduce a $25.20 si puedes esperar. Los trabajos por lotes (Batch jobs) intercambian un tiempo de respuesta de hasta 24 horas por límites de tasa más altos. Más detalles sobre los precios de Nano Banana 2 se encuentran en nuestro desglose de precios de la API de Nano Banana 2.

Errores comunes

Estos son comportamientos genéricos de la API de Gemini, no errores específicos de 2.1 documentados:

Preguntas frecuentes

• ¿Existe un nivel gratuito para la API de Nano Banana 2.1? No. Google lista el nivel gratuito de la API como "No disponible". El entorno de pruebas de AI Studio se vincula a 2.1, pero Google no ha publicado un límite gratuito para ello.
• ¿Es 2.1 un reemplazo directo para Nano Banana 2? Mayormente. Cambia el ID del modelo a gemini-nano-banana-2.1. Pierdes el nivel de 512px, y los tokens de entrada cuestan más, por lo que las ediciones con muchas referencias necesitan una verificación de costos.
• ¿Las imágenes generadas llevan una marca de agua? Sí. Todas las salidas incluyen una marca de agua SynthID.
• ¿Puedo generar una imagen a partir de un video? Sí. 2.1 acepta un bloque de entrada video, como una URL de YouTube, junto con tu prompt de texto.
• ¿La antigua guía de la API de Nano Banana 2 sigue siendo aplicable? Los conceptos sí. Consulta nuestra guía de la API de Nano Banana 2 para el modelo anterior.

Resumen

Nano Banana 2.1 promete mejores imágenes a la mitad del precio por imagen de Nano Banana 2, con la misma estructura de la API de Interacciones. Obtén una clave con facturación, genera una imagen y luego guarda la solicitud en Apidog con aserciones de estado e imagen. Duplícala con el ID del modelo antiguo, y sabrás en una tarde si 2.1 justifica el cambio para tus prompts.