Nano Banana Pro en Claude Code: crea un skill de imágenes

Claude Code puede generar y editar imágenes con Nano Banana Pro mediante un skill: una carpeta con un archivo SKILL.md y un script corto que llama a la API de SeedRouter. Escribes /nano-banana-pro y describes la imagen; Claude redacta el prompt y ejecuta el script, y el script envía la solicitud, sondea la tarea y guarda la imagen en tu proyecto. La misma carpeta funciona también en OpenAI Codex. SeedRouter no ofrece un skill oficial ni un servidor MCP, así que esta guía te da uno para copiar. El formato del skill sigue la documentación de Anthropic y OpenAI, comprobada el 29 de septiembre de 2026.

¿Cómo genera Claude Code imágenes con Nano Banana Pro?

Claude Code no dibuja imágenes por sí mismo. Ejecuta comandos, así que puede ejecutar un script que llame a una API de imágenes. Con un skill instalado, una solicitud funciona así:

Invocas el skill y describes la imagen, por ejemplo /nano-banana-pro a hero image for the pricing page.
Claude convierte tu descripción en un prompt de Nano Banana Pro y elige el tamaño y la relación de aspecto.
Ejecuta el script. El script envía la solicitud a POST https://api.seedrouter.ai/v1/images/generations y recibe un ID de tarea.
El script sondea GET /v1/tasks/{id} cada pocos segundos hasta que la imagen está lista y luego la descarga en una carpeta images/.
Claude te indica la ruta del archivo y después puede usar la imagen en tu código.

Un script, en lugar de solo instrucciones, mantiene exactas las llamadas a la API: el cuerpo de la solicitud, el bucle de sondeo y el guardado del archivo son iguales cada vez, escriba Claude el prompt que escriba.

¿Qué necesitas antes de empezar?

Una clave de API de SeedRouter, exportada en la terminal desde la que inicias Claude Code:

export SEEDROUTER_API_KEY="your-key"

Créditos. Cada ejecución es una solicitud de pago. Las cuentas nuevas empiezan con un pequeño saldo gratuito y las solicitudes fallidas no se cobran.
Python 3. El script solo usa la biblioteca estándar, así que no hay nada que instalar.

El script: enviar, sondear y guardar

Guarda esto como scripts/nano_banana_pro.py dentro de la carpeta del skill:

#!/usr/bin/env python3
import argparse
import json
import os
import pathlib
import sys
import time
import urllib.error
import urllib.request

API = "https://api.seedrouter.ai/v1"
AGENT = "nano-banana-pro-skill/1.0"
MIME = {
    ".jpg": "image/jpeg",
    ".jpeg": "image/jpeg",
    ".png": "image/png",
    ".webp": "image/webp",
    ".heic": "image/heic",
    ".heif": "image/heif",
}
RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"]


def call(method, path, body=None):
    request = urllib.request.Request(
        API + path,
        data=None if body is None else json.dumps(body).encode(),
        method=method,
        headers={
            "Authorization": "Bearer " + os.environ["SEEDROUTER_API_KEY"],
            "Content-Type": "application/json",
            "User-Agent": AGENT,
        },
    )
    try:
        with urllib.request.urlopen(request, timeout=60) as response:
            return json.load(response)
    except urllib.error.HTTPError as error:
        sys.exit(f"HTTP {error.code}: {error.read().decode()}")


def submit(args):
    parts = [{"text": args.prompt}]
    for url in args.ref:
        suffix = pathlib.PurePosixPath(url.split("?")[0]).suffix.lower()
        if suffix not in MIME:
            sys.exit(f"Cannot tell the image type of {url}; use a .jpg, .png, .webp, .heic or .heif URL.")
        parts.append({"fileData": {"mimeType": MIME[suffix], "fileUri": url}})
    image_config = {}
    if args.ratio:
        image_config["aspectRatio"] = args.ratio
    if args.size:
        image_config["imageSize"] = args.size
    generation_config = {"responseModalities": ["IMAGE"]}
    if image_config:
        generation_config["imageConfig"] = image_config
    body = {
        "model": args.model,
        "contents": [{"role": "user", "parts": parts}],
        "generationConfig": generation_config,
    }
    return call("POST", "/images/generations", body)["id"]


def wait(task_id, out_dir, timeout):
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
        task = call("GET", "/tasks/" + task_id)
        if task["status"] == "completed":
            out_dir.mkdir(parents=True, exist_ok=True)
            extension = "jpg" if task["output"]["output_format"] == "jpeg" else task["output"]["output_format"]
            for index, image in enumerate(task["output"]["data"]):
                path = out_dir / f"{task_id}-{index}.{extension}"
                download = urllib.request.Request(image["url"], headers={"User-Agent": AGENT})
                with urllib.request.urlopen(download, timeout=120) as response:
                    path.write_bytes(response.read())
                print(path)
            return
        if task["status"] == "failed":
            sys.exit(f"Task {task_id} failed: {task['error']['message']}")
        time.sleep(3)
    sys.exit(f"Task {task_id} is still processing. Resume with --resume {task_id}")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--prompt")
    parser.add_argument("--ref", action="append", default=[])
    parser.add_argument("--ratio", choices=RATIOS)
    parser.add_argument("--size", choices=["1K", "2K", "4K"])
    parser.add_argument("--model", default="gemini-3-pro-image",
                        choices=["gemini-3-pro-image", "gemini-3-pro-image-official"])
    parser.add_argument("--out", default="images")
    parser.add_argument("--timeout", type=int, default=600)
    parser.add_argument("--resume")
    args = parser.parse_args()
    if args.resume:
        task_id = args.resume
    elif args.prompt:
        task_id = submit(args)
        print(f"task {task_id}", file=sys.stderr)
    else:
        parser.error("--prompt or --resume is required")
    wait(task_id, pathlib.Path(args.out), args.timeout)


if __name__ == "__main__":
    main()

Qué hace:

Envía una sola vez. --prompt es el texto, --ref añade la URL de una imagen de referencia (repítelo para añadir varias) y --ratio y --size fijan imageConfig. El cuerpo de la solicitud es el formato generateContent de Google con un campo model, tal como lo define la referencia de la API de Nano Banana Pro.
Muestra el ID de la tarea en cuanto se crea la tarea, antes de esperar.
Sondea y luego guarda. Cuando la tarea termina, descarga cada imagen en images/ y muestra cada ruta. Cuando la tarea falla, muestra el motivo.
Reanuda en lugar de reenviar. Si la espera se agota, --resume <task id> vuelve a consultar la misma tarea. Un segundo envío sería una segunda solicitud de pago.
Envía una cabecera User-Agent. Conserva esa línea: algunos servidores rechazan la predeterminada de Python y, sin ella, la descarga puede fallar con un 403.

Puedes probarlo por separado antes de que Claude lo use:

python3 scripts/nano_banana_pro.py --prompt "A ceramic teapot on a linen tablecloth, soft window light" --ratio 16:9 --size 2K

El skill: ¿qué va en SKILL.md?

La documentación de Claude Code describe un skill como un directorio con un archivo SKILL.md: «frontmatter YAML entre marcadores --- que le dice a Claude cuándo usar el skill, y contenido markdown con las instrucciones que Claude sigue cuando el skill se ejecuta». Los archivos de apoyo, como una carpeta scripts/, van al lado.

Guarda esto como SKILL.md en la misma carpeta:

---
name: nano-banana-pro
description: Generate or edit an image with Nano Banana Pro (gemini-3-pro-image) through the SeedRouter API and save it into the project. Use when the user asks for an image, illustration, icon, poster or edit of an existing image.
argument-hint: "[what the image should show]"
disable-model-invocation: true
---

Create an image for this request: $ARGUMENTS

1. Write one prompt in full sentences: subject, framing, action, setting and style. Put any text that must appear in the image in double quotes and say where it goes. For an edit, say what changes and what must stay the same.
2. Choose --ratio from 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9 and --size from 1K, 2K, 4K (4K only for print).
3. Reference images must be public HTTPS URLs ending in .jpg, .png, .webp, .heic or .heif, passed with --ref. If the user points to a local file, ask for a public URL instead. Never send base64.
4. Show the user the prompt and options, and wait for approval. Each run is a paid request.
5. Run: python3 ${CLAUDE_SKILL_DIR}/scripts/nano_banana_pro.py --prompt "..." [--ratio R] [--size S] [--ref URL]
6. If it stops with "still processing", run it again with --resume and the same task ID. Never submit the same request twice.
7. Report the saved file paths. If the task failed, explain the reason and suggest a change to the prompt.

Aquí importan dos campos:

disable-model-invocation: true significa que solo tú puedes iniciar el skill. La documentación de Claude Code lo recomienda para «flujos de trabajo con efectos secundarios o cuyo momento quieres controlar». Cada ejecución cuesta dinero, así que Claude no debería decidir por su cuenta generar una imagen.
${CLAUDE_SKILL_DIR} se sustituye por la carpeta del propio skill, de modo que el script se ejecuta dondequiera que hayas instalado el skill.

¿Dónde se coloca el skill y cómo se ejecuta?

Claude Code carga los skills desde dos ubicaciones principales:

Ubicación	Ruta	Disponible en
Personal	`~/.claude/skills/nano-banana-pro/`	Todos tus proyectos en este equipo
Proyecto	`.claude/skills/nano-banana-pro/`	Este repositorio; haz commit para compartirlo con tu equipo

La carpeta terminada tiene este aspecto:

nano-banana-pro/
├── SKILL.md
└── scripts/
    └── nano_banana_pro.py

Inicia Claude Code en una terminal donde SEEDROUTER_API_KEY esté definida y escribe el nombre del skill seguido de lo que quieres:

/nano-banana-pro a 16:9 hero image for the pricing page: a calm desk with a laptop, a notebook and a cup of tea, soft morning light, muted green palette, no text

Claude muestra el prompt y las opciones, tú apruebas y la imagen llega a images/. Salvo que ya hayas autorizado el comando, Claude Code también pide permiso antes de ejecutar el script, lo que supone una segunda comprobación antes de que se cobre nada.

Sobre el prompt en sí, la guía de prompts de Nano Banana Pro profundiza en la estructura, el texto en la imagen y las referencias.

¿Puede Codex usar el mismo skill de Nano Banana Pro?

Sí. Ambas herramientas siguen el estándar abierto Agent Skills. La documentación de Codex de OpenAI dice que un skill «es un directorio con un archivo SKILL.md más scripts y referencias opcionales», y que el archivo «debe incluir name y description», algo que el skill de arriba tiene.

Codex busca los skills en otras carpetas:

Ubicación	Ruta
Personal	`~/.agents/skills/nano-banana-pro/`
Repositorio	`.agents/skills/nano-banana-pro/`

Copia allí la carpeta o crea un enlace simbólico a ella; ambas herramientas siguen las carpetas de skills enlazadas simbólicamente. En Codex, ejecuta /skills o escribe $nano-banana-pro para invocarlo.

Hay dos diferencias que conviene conocer:

La ruta del script. ${CLAUDE_SKILL_DIR} es una sustitución de Claude Code. Codex muestra al modelo la ruta del archivo de cada skill, así que puede encontrar scripts/nano_banana_pro.py junto a SKILL.md; si ejecuta una ruta equivocada, dile dónde está el script.
El uso automático. disable-model-invocation es un campo de Claude Code. El equivalente en Codex es un archivo agents/openai.yaml en la carpeta del skill con allow_implicit_invocation: false bajo policy, para que Codex solo ejecute el skill cuando tú lo invoques.

El script necesita acceso a la red para llegar a api.seedrouter.ai. Si tu agente se ejecuta en un sandbox sin red, permite el acceso a la red para esa sesión.

¿Cómo se editan imágenes que ya están en tu proyecto?

Nano Banana Pro edita a partir de imágenes de referencia, y la API solo las acepta como URL públicas. Un archivo de tu disco tiene que alojarse antes en algún sitio, por ejemplo en tu propio bucket de almacenamiento, y después pasarse con --ref.

Las imágenes generadas ya están alojadas: cada tarea terminada devuelve la imagen como URL. Para refinar un resultado, vuelve a pasar esa URL como referencia junto con el cambio que quieres:

/nano-banana-pro edit the last image: keep the desk and the laptop, change the tea cup to a glass of water, and make the light warmer

Claude reutiliza la URL de la imagen anterior con --ref y escribe un prompt de edición que dice qué debe quedarse igual. Para una edición en varios turnos que conserve el contexto propio del modelo entre turnos, la referencia de la API explica cómo reenviar los turnos anteriores; el script de arriba envía un turno cada vez.

Si ya usas GPT Image 2 desde un agente de programación, GPT Image 2 en Codex y Claude Code cubre esa configuración, que gira en torno a un prompt que pegas en el agente.

Preguntas frecuentes

¿Hay un skill o un servidor MCP oficial de Nano Banana Pro de SeedRouter?

No. SeedRouter no ofrece ninguno. El skill de esta guía es una carpeta normal que te pertenece y que puedes modificar, y llama a la API pública con tu clave.

¿Por qué el script sondea en lugar de esperar la imagen?

En SeedRouter, las solicitudes de Nano Banana Pro son tareas: al enviar una se devuelve un ID de tarea, y la imagen llega cuando la tarea termina. El sondeo mantiene cortas las conexiones y, si la espera se interrumpe, el ID de la tarea sigue siendo válido.

¿Puedo usar el mismo skill para Nano Banana 2?

Sí, con pequeños cambios. Cambia el valor predeterminado y las opciones de --model del script a gemini-3.1-flash-image y añade 512 a las opciones de --size, un tamaño que admite Nano Banana 2 y no Pro. Nano Banana 2 vs Pro vs 2 Lite compara los modelos.

¿Cargar el skill cuesta algo?

No. Que Claude lea SKILL.md no cuesta nada en SeedRouter. Cada ejecución del script es una solicitud, que se cobra a la tarifa de la página del modelo, y una tarea que falla no se cobra.

Empieza a generar desde Claude Code

Crea la carpeta, exporta tu clave y prueba primero /nano-banana-pro con una imagen pequeña. Los precios actuales están en la página de Nano Banana Pro, y todos los campos de la solicitud, en la referencia de la API.

Nano Banana Pro en Claude Code: un skill que genera y edita imágenes