# Nano Banana Pro Batch API: precio, fórmula y punto de equilibrio > Con Batch, Nano Banana Pro cuesta 0,067 $ por imagen 1K/2K y 0,12 $ en 4K, la mitad que Standard. Pagar 0,09 $ fijos por llamada gana en 4K; en 2K, rara vez. - URL: https://blog.laozhang.ai/es/posts/nano-banana-pro-batch-api-cost-optimization - Published: 2026-03-15 - Updated: 2026-10-05 - Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about) - Topic: Precios y planes de API - Tags: Nano Banana Pro, Batch API, Gemini 3 Pro Image, Precio API, Generación de imágenes --- A 4 de octubre de 2026, **Nano Banana Pro (`gemini-3-pro-image`) cuesta 0,067 $ por imagen 1K o 2K y 0,12 $ por imagen 4K en Batch**, el procesamiento asíncrono por lotes de la API de Gemini, con entrega en un plazo de hasta 24 horas. Es exactamente la mitad de Standard: 0,134 $ y 0,24 $. A ese precio de imagen se suman el prompt y los tokens de razonamiento, que en los modelos de imagen de Gemini 3 siempre están activos y se cobran: con 200 tokens de prompt y 1.000 de razonamiento, una imagen 2K por Batch sale a 0,0732 $. Con esas cifras la decisión depende sobre todo del tamaño: - **En 1K o 2K, Batch es la ruta más barata** mientras el razonamiento y el texto de salida no pasen de unos 3.800 tokens por llamada (con un prompt de 200 tokens y sin imágenes de referencia). Por encima, un precio fijo de 0,09 $ por llamada sale mejor. - **En 4K, solo la imagen por Batch (0,12 $) ya cuesta más que 0,09 $** fijos por llamada, antes de contar ningún token. - **Cualquier precio medio que mezcle rutas queda entre la más barata y la más cara.** Una media de Batch a 0,067 $ y llamadas a 0,09 $ no puede bajar de 0,067 $. Cada cifra de abajo lleva su fórmula y sus datos de entrada, para que la rehagas con tus propios tokens y volúmenes. ## Precio por imagen de Nano Banana Pro en Standard, Batch, Flex y Priority Las tarifas de Google son por token; la columna de imagen es el equivalente por imagen que publica la propia página de precios. Un 1K o un 2K genera 1.120 tokens de imagen y un 4K, 2.000. | Ruta | Imagen 1K o 2K | Imagen 4K | Entrada (por millón de tokens) | Imagen de referencia | Texto y razonamiento (por millón) | Entrega | |---|---|---|---|---|---|---| | Standard | 0,134 $ | 0,24 $ | 2 $ | 0,0011 $ | 12 $ | Síncrona, segundos o minutos | | Batch | 0,067 $ | 0,12 $ | 1 $ | 0,0006 $ | 6 $ | Asíncrona, objetivo de 24 horas | | Flex | 0,067 $ | 0,12 $ | 1 $ | 0,0006 $ | 6 $ | Síncrona, de 1 a 15 minutos, sin garantía | | Priority | 0,24192 $ (cálculo) | 0,432 $ (cálculo) | 3,60 $ | — | 21,60 $ | Síncrona, baja latencia | | Precio fijo por llamada (laozhang.ai) | 0,09 $ | 0,09 $ | Incluida | Incluida | Incluido | Síncrona | *Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.* Fuentes: [precios de la API de Gemini](https://ai.google.dev/gemini-api/docs/pricing) (página actualizada el 1 de octubre de 2026) y [precios de Nano Banana en LaoZhang API](https://docs.laozhang.ai/en/api-capabilities/nano-banana-image) (precio público a 24 de septiembre de 2026). Cómo leer la tabla: - **De dónde salen los precios por imagen.** Standard cobra 120 $ por millón de tokens de imagen: 1.120 × 120 / 1.000.000 = 0,1344 $, que Google redondea a 0,134 $; 2.000 × 120 / 1.000.000 = 0,24 $. Batch cobra 60 $ por millón, la mitad. Priority (216 $ por millón) no tiene precio por imagen publicado; 0,24192 $ y 0,432 $ son el resultado de aplicar esa tarifa a 1.120 y 2.000 tokens. - **1K y 2K cuestan lo mismo.** Bajar de 2K a 1K no reduce la factura de Nano Banana Pro. - **Pro solo genera 1K, 2K y 4K.** La referencia de la API admite `512` en `imageSize`, pero ese tamaño es de otros modelos; cualquier precio de 0,5K que veas atribuido a Pro es de Nano Banana 2. - **No hay nivel gratuito** para la salida de imagen de este modelo en la API. - **Vertex AI** (región global) aplica las mismas tarifas por token en Standard, Flex/Batch y Priority. - **El ID del modelo es `gemini-3-pro-image`.** La versión preview se cerró el 25 de junio de 2026. Si lo que buscas es la escalera completa, incluida la suscripción de Google, está en [Precio de Nano Banana Pro: 0,134 $ por imagen y cuándo usar 2.1](https://blog.laozhang.ai/es/posts/nano-banana-pro-pricing). ## Coste real por llamada: la fórmula con prompt, referencias y razonamiento El precio por imagen es solo una parte de la llamada. La factura de cada petición a Google se calcula así: ```text coste por llamada = precio de la imagen + tokens del prompt × tarifa de entrada + imágenes de referencia × precio por referencia + (tokens de razonamiento + texto de salida) × tarifa de texto ``` El error más fácil aquí es cobrar el razonamiento a la tarifa de imagen. No es así: los tokens de razonamiento y de texto se pagan a 6 $ por millón en Batch (12 $ en Standard), diez veces menos que los de imagen. Pesan poco por token, pero un modelo que razona mucho puede sumar varios miles por llamada. Con 200 tokens de prompt, ninguna imagen de referencia y 1.000 tokens de razonamiento: | Ruta y tamaño | Imagen | Prompt | Razonamiento | Total por llamada | |---|---|---|---|---| | Batch 2K | 0,067 $ | 200 × 1 / 1.000.000 = 0,0002 $ | 1.000 × 6 / 1.000.000 = 0,006 $ | 0,0732 $ | | Batch 4K | 0,12 $ | 0,0002 $ | 0,006 $ | 0,1262 $ | | Standard 2K | 0,134 $ | 0,0004 $ | 0,012 $ | 0,1464 $ | | Standard 4K | 0,24 $ | 0,0004 $ | 0,012 $ | 0,2524 $ | | Precio fijo, cualquier tamaño | — | — | — | 0,09 $ | Cada imagen de referencia añade 0,0006 $ en Batch y 0,0011 $ en Standard (560 tokens de entrada). Con dos fichas de producto como referencia, el Batch 2K del ejemplo pasa de 0,0732 $ a 0,0732 + 2 × 0,0006 = 0,0744 $. Los 200 y 1.000 tokens son supuestos. Los tuyos están en el `usageMetadata` de cada respuesta: `promptTokenCount` (prompt e imágenes de entrada), `thoughtsTokenCount` (razonamiento) y `candidatesTokenCount` (salida). Lanza una muestra pequeña con prompts representativos de tu trabajo y usa la media de esos campos en la fórmula. Si todavía no tienes la petición montada, la estructura está en [API de Nano Banana Pro: llamada oficial, plantillas JSON/YAML y errores](https://blog.laozhang.ai/es/posts/nano-banana-pro-api-guide). ## Batch o precio fijo por llamada: en 4K gana el fijo, en 2K gana Batch Un precio fijo por llamada no depende del tamaño ni del razonamiento. LaoZhang API cobra 0,09 $ por llamada a `gemini-3-pro-image` en 1K, 2K o 4K, y su documentación indica que el precio no cambia con 4K ni con razonamiento alto. Frente a Batch, el punto de equilibrio se calcula por tamaño. *Aviso: [laozhang.ai es un servicio propio](https://blog.laozhang.ai/es/about#laozhang). Sus precios son nuestra tarifa, no una comparación independiente.* **4K.** La imagen por Batch cuesta 0,12 $, así que el precio fijo es más barato desde la primera llamada: al menos 0,12 − 0,09 = 0,03 $ por imagen, y 0,1262 − 0,09 = 0,0362 $ con los tokens del ejemplo. **1K o 2K.** La imagen por Batch cuesta 0,067 $, así que quedan 0,09 − 0,067 = 0,023 $ de margen para el resto de tokens. Con 200 tokens de prompt (0,0002 $), el razonamiento y el texto de salida pueden llegar a: ```text (0,09 − 0,067 − 0,0002) / (6 / 1.000.000) = 0,0228 / 0,000006 = 3.800 tokens ``` Por debajo de 3.800 tokens por llamada gana Batch; por encima, el precio fijo. Cada imagen de referencia resta 0,0006 $ al margen, el equivalente a 100 tokens: con tres referencias, el límite baja a (0,0228 − 0,0018) / 0,000006 = 3.500 tokens. Frente a Standard la comparación es más simple: solo la imagen 2K ya cuesta 0,134 $, por encima de 0,09 $ en todos los tamaños. ![Barras de coste de Nano Banana Pro: en 1K o 2K, Batch cuesta 0,067 $ y deja 0,023 $ de margen hasta 0,09 $ fijos, unos 3.800 tokens; en 4K, Batch cuesta 0,12 $, 0,03 $ más que el precio fijo](https://blog.laozhang.ai/posts/es/nano-banana-pro-batch-api-cost-optimization/img/batch-vs-precio-fijo.webp) Con 10.000 imágenes al mes: | 10.000 imágenes | Standard | Batch | Precio fijo de 0,09 $ | |---|---|---|---| | 2K, solo salida de imagen | 1.340 $ | 670 $ | 900 $ | | 2K, con 200 tokens de prompt y 1.000 de razonamiento | 1.464 $ | 732 $ | 900 $ | | 4K, solo salida de imagen | 2.400 $ | 1.200 $ | 900 $ | | 4K, con 200 tokens de prompt y 1.000 de razonamiento | 2.524 $ | 1.262 $ | 900 $ | Cada celda es el coste por llamada de la sección anterior multiplicado por 10.000; no incluye reintentos. El precio no es la única diferencia. La ruta de precio fijo tiene sus propias reglas, según su documentación: - Una respuesta HTTP 200 sin imagen se cobra como una llamada. - Si tu cliente corta por tiempo de espera, el servidor puede terminar y cobrar igualmente: revisa el registro de llamadas antes de reintentar. - Los 429 y 503 rechazados antes de generar normalmente no se cobran. - El tamaño y la proporción solo se eligen en la ruta nativa de Gemini (`generateContent`); la ruta compatible con OpenAI devuelve 1:1 en 1K. El ahorro en 4K solo existe si usas la ruta nativa. - No ofrece un nivel por lotes ni descuento adicional. En Batch, en cambio, el plazo llega a 24 horas y la facturación de las líneas que fallan no está documentada (más abajo, cómo comprobarla). La comparación completa entre Google y la pasarela está en [Nano Banana API: Google y laozhang.ai, coste y entrega de imágenes](https://blog.laozhang.ai/es/posts/cheap-stable-nano-banana-api). ## Precio medio mezclado: la fórmula y por qué no baja de la ruta más barata Cuando repartes un trabajo entre varias rutas, el coste medio por imagen es una media ponderada: ```text media = Σ (fracción de imágenes de la ruta × coste por imagen de la ruta) con fracciones que suman 1 ``` Ese resultado siempre queda entre el coste más bajo y el más alto de las rutas que usas. Es la comprobación más rápida para cualquier «coste medio» que te den. **Ejemplo por urgencia.** El 70 % de las imágenes 2K va por Batch y el 30 % urgente, por precio fijo: - Solo imagen: 0,7 × 0,067 + 0,3 × 0,09 = 0,0469 + 0,027 = 0,0739 $. - Con los tokens del ejemplo: 0,7 × 0,0732 + 0,3 × 0,09 = 0,05124 + 0,027 = 0,0782 $ (redondeado). Las dos medias quedan entre 0,067 $ y 0,09 $, como debe ser. **Ejemplo por tamaño.** 8.000 imágenes 2K por Batch y 2.000 imágenes 4K por precio fijo, solo salida de imagen: - 8.000 × 0,067 + 2.000 × 0,09 = 536 + 180 = 716 $, es decir, 716 / 10.000 = 0,0716 $ por imagen. - Todo por Batch: 536 + 2.000 × 0,12 = 536 + 240 = 776 $. - Todo por precio fijo: 10.000 × 0,09 = 900 $. Repartir por tamaño ahorra 776 − 716 = 60 $ frente a mandarlo todo por Batch. La media de 0,0716 $ sigue entre 0,067 $ y 0,09 $. ![Escala del precio medio mezclado de Nano Banana Pro entre 0,067 $ y 0,09 $, con el ejemplo por tamaño de 0,0716 $ y las tres comprobaciones antes de aceptar una media](https://blog.laozhang.ai/posts/es/nano-banana-pro-batch-api-cost-optimization/img/precio-medio-mezclado.webp) Antes de aceptar un precio mezclado, revisa tres cosas: 1. Que las fracciones sumen 1 (o los volúmenes, el total de imágenes). 2. Que todos los costes sean del mismo modelo. Un precio de Nano Banana 2, como sus 0,022 $ por imagen 0,5K en Batch, no sirve para calcular una media de Pro, que ni siquiera genera ese tamaño. 3. Que el resultado quede entre el mínimo y el máximo. Una media de Pro por debajo de su ruta más barata indica un error de cálculo o un modelo distinto. ## Coste por imagen utilizable: divide entre (1 − tasa de descarte) Si una parte de las imágenes cobradas no te sirve y tienes que regenerarla, el coste por imagen buena es: ```text coste por imagen utilizable = coste por intento / (1 − tasa de descarte) ``` Con una tasa de descarte del 20 %: - Batch 2K: 0,067 / 0,8 = 0,08375 $. - Batch 4K: 0,12 / 0,8 = 0,15 $. - Precio fijo en 4K: 0,09 / 0,8 = 0,1125 $. La tasa de descarte es la que mides tú con tu propio trabajo; Google no publica ninguna. La fórmula vale para los intentos que se cobran: las imágenes que descartas por calidad se pagan siempre, y en la ruta de precio fijo también la respuesta 200 sin imagen. Si una ruta te obliga a descartar más que otra (por ejemplo, porque no te deja fijar el tamaño o la proporción que necesitas), compara rutas con este coste por imagen utilizable y no con el precio por llamada. Para las respuestas sin imagen, el diagnóstico está en [Nano Banana no genera imagen en la API: diagnóstico y arreglo](https://blog.laozhang.ai/es/posts/nano-banana-2-200-ok-no-image). ## Cómo repartir el trabajo: qué puede esperar 24 horas y qué no | Tu caso | Ruta con menor coste | Coste por imagen (solo salida) | |---|---|---| | Catálogo, dataset o variantes en 1K/2K que pueden esperar hasta un día | Batch | 0,067 $ | | Lo mismo en 4K | Precio fijo por la ruta nativa de Gemini; Batch si necesitas facturar con Google | 0,09 $ frente a 0,12 $ | | El usuario espera la imagen en pantalla | Precio fijo o Standard | 0,09 $ frente a 0,134 $ (2K) | | Flujo secuencial que tolera minutos de espera | Flex, solo si tu prueba funciona | 0,067 $ | | Puedes cambiar de modelo y aceptar otra calidad | Nano Banana 2 por Batch | 0,034 $ (1K) / 0,050 $ (2K) / 0,076 $ (4K) | **Flex: prueba primero con una petición.** Flex es un nivel síncrono de «mejor esfuerzo»: cuesta la mitad, tarda de 1 a 15 minutos y usa capacidad que Google puede retirar en picos. La página de precios muestra tarifas Flex para `gemini-3-pro-image`, idénticas a las de Batch, pero la guía de Flex solo incluye modelos de texto en su lista de modelos compatibles. Antes de pasar un flujo a Flex, envía una petición con `service_tier` en `flex`, comprueba que devuelve imagen, mira el campo `serviceTier` de `usageMetadata` y confirma el descuento en tu facturación. Ten preparada otra ruta: Flex responde 503 cuando no hay capacidad y 429 al agotar límites, y cuenta contra tus límites normales, sin el margen extra que tiene Batch. Cómo tratar esos errores: [Nano Banana API no funciona: arregla 429, 503, sin imagen y request denied](https://blog.laozhang.ai/es/posts/nano-banana-pro-error). **Nano Banana 2 es otra palanca, no un descuento.** `gemini-3.1-flash-image` cuesta en Batch 0,034 $ en 1K, 0,050 $ en 2K y 0,076 $ en 4K (0,067 $, 0,101 $ y 0,151 $ en Standard). Es otro modelo, con otra calidad: pruébalo con muestras de tu propio catálogo antes de mover el trabajo. ## Antes de lanzar un lote: 24 horas, caducidad a las 48 y líneas fallidas El descuento de Batch se paga en plazo y en trabajo de control. Esto es lo que dice la [documentación de Batch API](https://ai.google.dev/gemini-api/docs/batch-api) (actualizada el 17 de septiembre de 2026) y lo que implica para el coste: - **Plazo.** El objetivo es terminar en 24 horas; según Google, la mayoría de los trabajos acaban mucho antes. Planifica con 24 horas. - **Caducidad.** Un trabajo que lleva más de 48 horas pendiente o en ejecución pasa a `JOB_STATE_EXPIRED` y no deja resultados. Tienes que reenviarlo o partirlo en lotes más pequeños, así que una fecha de entrega ajustada necesita margen. - **Formato.** Para imágenes se recomienda un archivo JSONL subido con la File API (hasta 2 GB); las peticiones en línea solo sirven por debajo de 20 MB. Cada línea lleva una `key` tuya y la línea de resultado vuelve con la misma `key` y un `response` o un `error`. Usa el SKU como clave y podrás relanzar solo lo que falló. - **Estados.** Un trabajo puede terminar en `SUCCEEDED`, `FAILED`, `CANCELLED` o `EXPIRED`. `SUCCEEDED` no significa que todas las líneas tengan imagen. - **Conservación.** Los resultados se guardan 6 semanas y después se borran para siempre. Descárgalos al terminar. - **Cancelación.** Cancelar detiene el procesamiento de las peticiones nuevas. - **Avisos.** En lugar de consultar el estado una y otra vez, puedes registrar un webhook para `batch.succeeded` y `batch.failed`. - **Facturación de lo que falla.** Google no documenta si se cobran las líneas con error dentro de un trabajo terminado ni cómo se factura lo ya procesado en un trabajo cancelado. Una línea del JSONL tiene esta forma. Es la estructura del ejemplo de imágenes de la documentación de Google, con `imageConfig` añadido según la referencia de la API; pásala primero por un lote pequeño: ```json {"key": "sku-0001", "request": {"contents": [{"parts": [{"text": "Foto de producto: taza de cerámica blanca sobre fondo gris claro, luz suave"}]}], "generation_config": {"responseModalities": ["TEXT", "IMAGE"], "imageConfig": {"imageSize": "2K", "aspectRatio": "1:1"}}}} ``` Al crear el trabajo, el modelo es `gemini-3-pro-image`. Para saber si se te cobraron las líneas fallidas, compara lo que deberían costar las líneas con imagen con lo que marca tu informe de facturación. Este script recorre el JSONL de resultados, separa líneas con imagen, sin imagen y con error, y estima el coste de las que sí tienen imagen con las tarifas Batch: ```python """Revisa el JSONL de resultados de un trabajo Batch de Nano Banana Pro.""" import json import sys TARIFA_IMAGEN = {"1K": 0.067, "2K": 0.067, "4K": 0.12} # Batch, USD por imagen ENTRADA_POR_M = 1.00 # Batch, USD por 1M tokens de entrada SALIDA_TEXTO_POR_M = 6.00 # Batch, USD por 1M tokens de texto y razonamiento def revisar(ruta, tamano="2K"): con_imagen, sin_imagen, con_error = [], [], [] estimado = 0.0 with open(ruta, encoding="utf-8") as f: for linea in f: if not linea.strip(): continue d = json.loads(linea) clave = d.get("key") resp = d.get("response") if not resp: con_error.append(clave) continue partes = [] for cand in resp.get("candidates", []): partes += cand.get("content", {}).get("parts", []) imagenes = sum(1 for p in partes if "inlineData" in p) if imagenes == 0: sin_imagen.append(clave) continue con_imagen.append(clave) uso = resp.get("usageMetadata", {}) estimado += (imagenes * TARIFA_IMAGEN[tamano] + uso.get("promptTokenCount", 0) * ENTRADA_POR_M / 1_000_000 + uso.get("thoughtsTokenCount", 0) * SALIDA_TEXTO_POR_M / 1_000_000) return {"con_imagen": len(con_imagen), "sin_imagen": sin_imagen, "con_error": con_error, "estimado_lineas_con_imagen": round(estimado, 4)} if __name__ == "__main__": ruta = sys.argv[1] tamano = sys.argv[2] if len(sys.argv) > 2 else "2K" print(json.dumps(revisar(ruta, tamano), ensure_ascii=False, indent=1)) ``` Ejecútalo con `python3 revisar_resultados.py resultados.jsonl 2K`. Con un archivo sintético de cuatro líneas que sigue la estructura de la documentación (dos con imagen y los tokens del ejemplo, una sin imagen y una con error), devuelve 0,1464 $ para las dos líneas con imagen en 2K, es decir, 2 × 0,0732 $. La salida de un trabajo real puede traer campos que el archivo sintético no tiene, así que abre antes unas cuantas líneas a mano. La estimación deja fuera el texto que acompaña a la imagen, que suele ser poco; si tu factura supera claramente esa cifra y tienes líneas sin imagen o con error, esas líneas se cobraron. Las claves de `sin_imagen` y `con_error` son las que tienes que relanzar. ## Calculadora en Python para estimar la factura de tu lote Esta calculadora reúne las fórmulas anteriores: coste por llamada según ruta y tamaño, coste por imagen utilizable y media mezclada. No llama a ninguna API ni sustituye a la factura; las tarifas están escritas a mano en `RATES` y tienes que actualizarlas cuando cambien los precios. ```python """Estima la factura de un trabajo con Nano Banana Pro (gemini-3-pro-image) por ruta. Tarifas: precios publicados por Google a 4 de octubre de 2026 (USD) y una pasarela con precio fijo por llamada; actualiza RATES cuando cambien. Es un estimador, no un registro de facturación. """ RATES = { # salida de imagen: precio por imagen según tamaño; salida de texto/razonamiento y entrada: por 1M de tokens "standard": {"image": {"1K": 0.134, "2K": 0.134, "4K": 0.24}, "text_out_per_m": 12.00, "input_per_m": 2.00, "ref_image": 0.0011}, "batch": {"image": {"1K": 0.067, "2K": 0.067, "4K": 0.12}, "text_out_per_m": 6.00, "input_per_m": 1.00, "ref_image": 0.0006}, # ruta con precio fijo: un precio por llamada, sea cual sea el tamaño o el razonamiento "per_call": {"flat": 0.09}, } def cost_per_call(route, size, prompt_tokens=200, thinking_tokens=1000, ref_images=0): r = RATES[route] if "flat" in r: return r["flat"] return (r["image"][size] + prompt_tokens * r["input_per_m"] / 1_000_000 + ref_images * r["ref_image"] + thinking_tokens * r["text_out_per_m"] / 1_000_000) def cost_per_usable_image(call_cost, reject_rate): """Se cobra cada intento; una fracción reject_rate de los resultados no sirve.""" if not 0 <= reject_rate < 1: raise ValueError("reject_rate debe estar en [0, 1)") return call_cost / (1 - reject_rate) def blended(shares_and_costs): """shares_and_costs: lista de (fracción, coste); las fracciones deben sumar 1.""" total_share = sum(s for s, _ in shares_and_costs) if abs(total_share - 1) > 1e-9: raise ValueError("las fracciones deben sumar 1") return sum(s * c for s, c in shares_and_costs) if __name__ == "__main__": images, size = 10_000, "2K" for route in ("standard", "batch", "per_call"): c = cost_per_call(route, size) print(f"{route:9s} {size}: ${c:.4f} por llamada, ${c * images:,.2f} por {images:,} imágenes") mix = blended([(0.7, cost_per_call("batch", size)), (0.3, cost_per_call("per_call", size))]) print(f"70 % batch + 30 % precio fijo: ${mix:.4f} por imagen") ``` Salida con Python 3.12.1 (el script imprime los números en formato inglés): ```text standard 2K: $0.1464 por llamada, $1,464.00 por 10,000 imágenes batch 2K: $0.0732 por llamada, $732.00 por 10,000 imágenes per_call 2K: $0.0900 por llamada, $900.00 por 10,000 imágenes 70 % batch + 30 % precio fijo: $0.0782 por imagen ``` Una batería de 12 comprobaciones pasa con este código: reproduce los totales de 0,0732 $, 0,1262 $ y 0,1464 $, la media de 0,0739 $, el coste utilizable de 0,08375 $ y el límite de 3.800 tokens, y verifica que 1.000 mezclas aleatorias quedan siempre entre su mínimo y su máximo. Para tu trabajo, cambia `prompt_tokens`, `thinking_tokens` y `ref_images` por las medias de tu `usageMetadata`, y las fracciones de `blended` por tu reparto real. ## Preguntas frecuentes sobre el precio de Nano Banana Pro en Batch ### ¿Cuánto cuesta la API de Nano Banana Pro por imagen? A 4 de octubre de 2026, en Standard cuesta 0,134 $ por imagen 1K o 2K y 0,24 $ en 4K; en Batch, 0,067 $ y 0,12 $. A eso se suman el prompt y el razonamiento: con 200 y 1.000 tokens, una imagen 2K sale a 0,1464 $ en Standard y a 0,0732 $ en Batch. ### ¿Hay nivel gratuito en la API de Nano Banana Pro? No. La página de precios de Google marca el nivel gratuito como «no disponible» para la salida de imagen de `gemini-3-pro-image`. Las opciones de suscripción se comparan en [Precio de Nano Banana Pro: 0,134 $ por imagen y cuándo usar 2.1](https://blog.laozhang.ai/es/posts/nano-banana-pro-pricing). ### ¿Cuánto tarda un trabajo Batch de Nano Banana Pro? El objetivo de Google es un máximo de 24 horas, y la mayoría terminan antes. Si un trabajo sigue pendiente o en ejecución pasadas 48 horas, caduca sin resultados y tienes que reenviarlo. ### ¿Funciona Flex con Nano Banana Pro? Tiene precio publicado (el mismo que Batch), pero `gemini-3-pro-image` no figura en la lista de modelos compatibles de la guía de Flex. Envía una petición de prueba con `service_tier` en `flex` y comprueba la imagen, el campo `serviceTier` y la facturación antes de depender de él. ### ¿Se cobran las líneas que fallan dentro de un lote? Google no lo documenta. Suma lo que deberían costar las líneas con imagen a partir de su `usageMetadata` y compáralo con tu informe de facturación; si la factura es claramente mayor y hay líneas con error o sin imagen, se cobraron. ## Fuentes Páginas externas que cita esta guía, en el orden en que aparecen. Última actualización: 2026-10-05. - [precios de la API de Gemini](https://ai.google.dev/gemini-api/docs/pricing) (ai.google.dev) - [documentación de Batch API](https://ai.google.dev/gemini-api/docs/batch-api) (ai.google.dev)