Seed en Nano Banana Pro: cómo repetir imágenes y mantener la coherencia

Si necesitas repetir exactamente una imagen de Nano Banana Pro, guarda y reutiliza el archivo aprobado. Si necesitas una imagen nueva con el mismo sujeto, trabaja con referencias y especifica qué debe conservarse y qué puede cambiar. El parámetro seed, o semilla, es un control adicional cuando tu interfaz lo admite; no equivale a guardar el resultado ni garantiza una copia idéntica.

Google sí documenta seed en la configuración general de generateContent, con la advertencia de que no todos los parámetros pueden configurarse en todos los modelos. Por tanto, tampoco es correcto afirmar que «la API de Google no tiene seed» a partir de su ausencia en un ejemplo de generación de imágenes. La compatibilidad concreta con Pro y la reproducibilidad del resultado son cuestiones diferentes. Referencia de GenerationConfig.

Elige según lo que deba repetirse

Antes de cambiar parámetros, decide qué significa «la misma imagen» para tu trabajo:

Una copia de archivo, una imagen con los mismos píxeles y una imagen visualmente parecida no son lo mismo. Dos PNG pueden mostrar los mismos píxeles y tener bytes distintos por los metadatos o la compresión. Un hash del archivo sirve para comprobar el primer caso; para el segundo habría que decodificar las imágenes y comparar dimensiones, canales y píxeles. La coherencia de una serie exige además revisar aquello que importa en el diseño, aunque los archivos sean necesariamente distintos.

¿Dónde se configura seed y qué garantiza?

En el esquema general de Google, seed es un entero dentro de generationConfig. No es un campo de imageConfig, que contiene opciones de imagen como aspectRatio e imageSize. Este fragmento muestra la ubicación del campo en el esquema general, no una petición cuya compatibilidad con Pro hayamos comprobado:

{
  "generationConfig": {
    "seed": 271828,
    "imageConfig": {
      "aspectRatio": "16:9",
      "imageSize": "2K"
    }
  }
}

El fragmento no incluye el contenido de entrada ni realiza una llamada. La documentación general de Google define el campo, pero avisa de las diferencias entre modelos. La descripción de seed en Google Cloud habla de un esfuerzo por repetir la respuesta, sin garantizar una salida determinista; cambiar el modelo o la temperatura puede cambiar el resultado incluso con la misma semilla. Esa descripción general tampoco es una prueba de comportamiento específica de Pro.

Hay interfaces de otros proveedores que sí incluyen el campo en su documentación de Nano Banana Pro. El endpoint de Ideogram para Pro y la documentación de Pro en Runware publican un rango de 0 a 2147483647 para la semilla indicada por el usuario. Ideogram también documenta la devolución de la semilla y un identificador de generación. Son contratos de esos servicios: no demuestran que el endpoint directo de Google acepte las mismas opciones ni que dos imágenes tengan píxeles idénticos.

Si estás eligiendo una integración, separa tres comprobaciones: que la interfaz documente el campo para ese modelo, que la petición lo acepte y que el resultado alcance la repetibilidad que necesitas. Un 200 OK solo resolvería la segunda. Anota el servicio, el endpoint, el modelo solicitado y devuelto cuando esté disponible, la semilla, las referencias, el texto exacto y los ajustes; guarda también los archivos resultantes. Así podrás comparar resultados sin atribuir cualquier diferencia a seed.

El modelo estable de Pro en la API de Gemini es gemini-3-pro-image. No reutilices sin revisar un tutorial con gemini-3-pro-image-preview: Google cerró esa versión el 25 de junio de 2026 y señala el modelo estable como sustituto. Ficha del modelo y calendario de retirada.

Mantén el producto y cambia la escena con referencias

Imagina que has aprobado una lámpara portátil para un catálogo: pantalla abombada amarilla, base cilíndrica del mismo color, asa negra y un único botón redondo en la parte frontal. Ahora necesitas colocarla en una mesilla, en una biblioteca y en una terraza. Repetir «lámpara amarilla» deja demasiados detalles por decidir; una semilla tampoco describe cuáles son los detalles que quieres conservar.

Prepara una referencia frontal nítida y otra lateral, sin contradicciones de forma o color. Si la imagen aprobada ya define el acabado de la campaña, adjúntala como referencia adicional y explica su función. Google documenta hasta 14 imágenes de referencia para Pro; su tabla distingue hasta seis referencias de objetos, cinco de personajes y tres de estilo. Son categorías de imágenes de entrada, no una garantía de ese número de sujetos idénticos en la salida. Guía de generación de imágenes.

Puedes empezar con esta instrucción, adaptando los archivos a los que realmente adjuntes:

Usa las imágenes 1 y 2 como referencias del mismo producto.
Conserva la pantalla abombada amarilla, la base cilíndrica amarilla,
el asa negra y el único botón redondo frontal. Mantén sus proporciones
y el acabado mate. No añadas botones, cables ni inscripciones.

Coloca la lámpara sobre una mesa de lectura de madera en una biblioteca.
La lámpara es el elemento principal y se ve completa, en un encuadre
horizontal. Cambia únicamente el entorno y la iluminación para que
encaje en la escena. No rediseñes el producto.

Ilustración del proceso con referencias; no es una comparación de salidas de Nano Banana Pro.

Para la terraza, cambia el párrafo del entorno y conserva las instrucciones del producto. Mantener ese bloque ayuda a organizar la serie; no implica que el modelo vaya a obedecerlo sin errores. Si la nueva imagen cambia el asa o añade un segundo botón, señala el fallo de forma concreta y vuelve a aportar las referencias del producto. «Hazla más parecida» ofrece menos información que «restaura el asa negra de la imagen 2 y elimina el botón adicional».

En una conversación de edición puedes continuar desde una imagen que funciona y pedir el siguiente cambio. Para una serie comercial conviene conservar también la referencia original aprobada, de modo que puedas volver a ella si los turnos posteriores se alejan del producto. Es una forma de mantener control sobre el trabajo, no una tasa de éxito medida ni una garantía de identidad.

Cuando una variación modifica un detalle importante, comprueba primero que la referencia muestra ese detalle y que no has dado instrucciones incompatibles. Si solo necesitas otro formato, evita pedir que se genere de nuevo todo el producto: parte del archivo aprobado y haz el recorte o la adaptación local. Para añadir espacio o cambiar el fondo puedes necesitar edición generativa, que vuelve a exigir comprobar la zona que debía permanecer estable.

Archiva el original para recuperarlo sin otra generación

Guardar solo el texto y seed no basta para entregar de nuevo una pieza aprobada. Conserva el archivo original junto con el contexto de generación. El siguiente programa usa únicamente la biblioteca estándar de Python: archiva un archivo de imagen y un JSON, calcula su SHA-256 y permite recuperar una copia después de comprobar la integridad del archivo guardado. No llama a ninguna API ni compara la calidad de un modelo.

Guárdalo como archivo_aprobado.py:

import argparse
import hashlib
import json
from pathlib import Path
import shutil

def sha256(ruta):
    return hashlib.sha256(ruta.read_bytes()).hexdigest()

parser = argparse.ArgumentParser()
acciones = parser.add_subparsers(dest="accion", required=True)
guardar = acciones.add_parser("guardar")
guardar.add_argument("imagen", type=Path)
guardar.add_argument("contexto", type=Path)
guardar.add_argument("carpeta", type=Path)
usar = acciones.add_parser("usar")
usar.add_argument("carpeta", type=Path)
usar.add_argument("destino", type=Path)
args = parser.parse_args()

if args.accion == "guardar":
    contexto = json.loads(args.contexto.read_text(encoding="utf-8"))
    extension = args.imagen.suffix.lower()
    if extension not in {".png", ".jpg", ".jpeg", ".webp"}:
        raise SystemExit("Formato de archivo no admitido")
    original = args.imagen.read_bytes()
    args.carpeta.mkdir(parents=True, exist_ok=False)
    nombre = "original" + extension
    (args.carpeta / nombre).write_bytes(original)
    registro = {
        "archivo": nombre,
        "bytes": len(original),
        "sha256": hashlib.sha256(original).hexdigest(),
        "contexto": contexto
    }
    (args.carpeta / "registro.json").write_text(
        json.dumps(registro, ensure_ascii=False, indent=2),
        encoding="utf-8"
    )
    print("Original archivado:", args.carpeta)
else:
    registro = json.loads(
        (args.carpeta / "registro.json").read_text(encoding="utf-8")
    )
    origen = args.carpeta / registro["archivo"]
    if (origen.stat().st_size != registro["bytes"]
            or sha256(origen) != registro["sha256"]):
        raise SystemExit("El original guardado ha cambiado")
    if args.destino.exists():
        raise SystemExit("El destino ya existe; usa otro nombre")
    args.destino.parent.mkdir(parents=True, exist_ok=True)
    shutil.copyfile(origen, args.destino)
    if sha256(args.destino) != registro["sha256"]:
        raise SystemExit("La copia no coincide con el original")
    print("Copia idéntica guardada:", args.destino)

Crea un contexto.json con tus datos reales. Este ejemplo es un registro local, no el cuerpo de una petición de Google; null significa que no tienes una semilla confirmada:

{
  "pieza": "Lampara en biblioteca, version aprobada",
  "servicio": "Anotar el servicio utilizado",
  "modelo_solicitado": "gemini-3-pro-image",
  "seed_confirmada": null,
  "referencias": ["lampara-frontal.png", "lampara-lateral.png"],
  "instruccion": "Guardar aqui el texto exacto utilizado",
  "ajustes": {"formato": "16:9", "resolucion": "2K"}
}

Con aprobada.png y contexto.json en tu carpeta de trabajo, ejecuta:

python3 archivo_aprobado.py guardar aprobada.png contexto.json archivo/lampara-biblioteca
python3 archivo_aprobado.py usar archivo/lampara-biblioteca entregas/lampara-biblioteca.png

El archivo se recupera del original guardado, sin pedir otra generación al modelo.

La primera orden crea una carpeta nueva; no sustituye un archivo anterior. La segunda verifica el original y entrega una copia con los mismos bytes. Los nombres de las referencias se registran, pero sus archivos no se copian: consérvalos junto al proyecto si quieres poder volver a editar. Para uso duradero, respalda también la carpeta de originales. Un hash detecta cambios respecto al registro; no recupera un archivo perdido ni autentica quién lo aprobó.

Comprobamos este ejemplo localmente con un archivo sintético: archivado y recuperación correctos, rechazo de un original modificado y rechazo de un destino existente. Esa comprobación verifica la lógica del programa, no la aceptación de seed ni la reproducibilidad de Nano Banana Pro.

Selecciona variantes sin confundir coste con repetibilidad

Cuando el entorno cambia mucho, puede resultar más práctico generar candidatas y elegir una que volver a insistir en la misma petición. Define antes qué vas a aceptar: producto completo, asa y botón correctos, proporciones conservadas, espacio suficiente para la composición y ausencia de elementos añadidos. Guarda la candidata aprobada, incluso si luego continúas editándola.

La selección tiene un coste que depende de cuántas salidas uses. En Pro Standard, Google publica 0,134 USD por la parte de salida de imagen a 1K o 2K y 0,24 USD a 4K; entrada, texto y razonamiento se contabilizan aparte. El cálculo con los 1.120 tokens de salida publicados es 1120 × 120 / 1000000 = 0,1344 USD. No hay nivel gratuito de API para este modelo en la tabla consultada. Precios de Pro y notas de cálculo.

Por ejemplo, si produces cuatro salidas a 2K y apruebas una, el componente de salida de imagen suma aproximadamente 0,5376 USD por esa pieza aprobada, antes de los demás componentes. Es un supuesto de planificación, no una factura ni una tasa de acierto medida. Si apruebas dos, ese mismo componente se reparte entre dos piezas. Cuenta resultados utilizables y conserva los originales para evitar pagar por intentar reconstruir una imagen que ya tenías.

Cuándo conviene cambiar de herramienta

Si el requisito del proyecto es controlar una semilla como parámetro explícito, empieza por una interfaz con documentación específica para Pro, como las citadas de Ideogram o Runware, y comprueba sus condiciones antes de integrarla. No supongas que el mismo campo significa lo mismo en todos los servicios.

Si necesitas transformaciones locales repetibles —un tamaño de salida, un recorte o una conversión concreta—, fija el archivo de entrada, las opciones y la versión de la herramienta de exportación. Si necesitas controlar todo el proceso de generación, estudia una solución cuyo entorno puedas mantener; una semilla por sí sola no fija bibliotecas, operaciones ni hardware. La documentación de reproducibilidad de PyTorch advierte de diferencias entre versiones, plataformas y CPU/GPU incluso usando semillas iguales. Esto describe procesos controlados por el usuario, no la implementación interna de Pro.

Tampoco sigas un tutorial antiguo que presenta Imagen de Google como alternativa disponible sin revisar la versión: los modelos Imagen 4 de la API de Gemini se retiraron el 17 de agosto de 2026, mientras que los endpoints Imagen 4 de Vertex AI que figuran en su ficha se discontinuaron el 30 de junio de 2026. Son servicios y fechas distintos. Retiradas en Gemini y estado de Imagen 4 en Vertex AI.

Preguntas frecuentes

¿Nano Banana Pro tiene seed?

La configuración general de la API de Gemini contiene seed, pero Google advierte que no todos sus parámetros se pueden configurar en cada modelo. No basta ese esquema para confirmar su aceptación específica en Pro. Ideogram y Runware sí documentan seed en sus propias interfaces de Pro; eso acredita sus contratos, no una garantía de píxeles idénticos. Google, Ideogram y Runware.

¿La misma semilla devuelve exactamente la misma imagen?

No puedes darlo por garantizado. Google describe la repetición con seed como un esfuerzo por obtener la misma respuesta, sin garantizar determinismo. Para volver a entregar exactamente un archivo aprobado, recupéralo del original guardado; para una escena nueva, revisa los detalles que deban mantenerse. Condiciones de seed en Google Cloud.

¿Poner la temperatura a cero soluciona la falta de coherencia?

No es una garantía de identidad visual ni de igualdad de archivos. Además, la compatibilidad de los parámetros depende del modelo. Si quieres que una lámpara conserve su diseño en otra habitación, aporta referencias claras y describe los rasgos que deben mantenerse; la temperatura no identifica esos rasgos por ti. Configuración general de generación.

¿Qué hago si no veo seed en la aplicación que uso?

Conserva el original aprobado si necesitas repetirlo. Si necesitas escenas nuevas, usa las referencias y las opciones de edición que esa aplicación ofrezca. Para una integración que requiera una semilla explícita, consulta la documentación de su endpoint concreto; un tutorial sobre otro proveedor no añade el control a tu aplicación.

¿Por qué cambia el producto aunque repita las mismas instrucciones?

Las instrucciones repetidas no constituyen un contrato de identidad. Comprueba que las referencias permitan ver el detalle que cambia, que no haya contradicciones entre ellas y que la nueva escena no pida rediseñar el objeto. Corrige el rasgo concreto y vuelve a la referencia aprobada. Sin información del servicio y una comparación adecuada, no se puede atribuir el cambio a una causa técnica específica.