Cuánto cuestan 10 000 imágenes: calcula tu presupuesto

01¿Cómo se calcula el presupuesto de generación?

El precio se indica por imagen y depende del modelo y de la resolución. Por eso el presupuesto de un mes es la suma de los resultados de multiplicar por cada combinación que uses: total = imágenes × precio.

Por combinación necesitas las imágenes terminadas que esperas al mes y su precio. Es el de tu cuenta, que devuelve GET /models: toma el de variants, el de cada resolución, y no el price raíz, que es el de la resolución más barata (Modelos y parámetros).

Indica siempre resolution: sin ese campo se cobra la resolución predeterminada del modelo, 2K en Nano Banana Pro, Nano Banana 2 y Nano Banana 2.1, y 1K en los demás (Modelos y parámetros).

02¿Qué se cobra y qué no?

El cargo se hace al aceptar la solicitud, antes de empezar el trabajo. Si la imagen no sale, el importe vuelve solo al saldo: una solicitud fallida es gratis (Saldo), también cuando las reglas de contenido rechazan la solicitud (Códigos de error).

Por eso el presupuesto cuenta solo las imágenes terminadas. Un intento nuevo es otra solicitud, con una clave de idempotencia nueva y su propio cargo (Reintentos sin doble cargo). Más sobre el cargo y el reembolso: Una solicitud fallida es gratis: así funciona el pago por imagen.

03¿Cómo sale la cuenta con un volumen de ejemplo?

Tomemos 10 000 imágenes al mes como volumen de ejemplo: un supuesto, no el tráfico de una cuenta real. Los precios están en dólares estadounidenses. Cada caso las multiplica por el precio de un modelo y una resolución:

• Nano Banana Flash en 1K: 10 000 imágenes a $0,015 por imagen.
• Nano Banana 2.1 en 2K: 10 000 imágenes a $0,03 por imagen (precio de Nano Banana 2.1).
• Nano Banana Pro en 4K: 10 000 imágenes a $0,07 por imagen (precio de Nano Banana Pro).

En un mes mixto, por ejemplo con 6 000 imágenes de Nano Banana Flash en 1K, 3 000 de Nano Banana 2.1 en 2K y 1 000 de Nano Banana Pro en 4K, el total es la suma de cada cantidad por su precio. No escribimos totales: la suma está en la página de precios.

04¿Qué muestran las tres imágenes de este artículo?

Las tres imágenes ilustran esas combinaciones. Cada una sale de un prompt distinto y de un solo intento, así que no comparan calidad. Las tres muestran una pastilla de jabón crema y ninguna lleva texto; el pie de cada una dice en qué se aparta de su prompt.

Prompt: pastilla de jabón sobre papel azul

Una pastilla rectangular de jabón crema sobre una base de papel azul pálido. Vista de tres cuartos, bordes redondeados, luz suave de la izquierda y sombra corta. Composición mínima con el jabón entero al centro y fondo liso amplio. Sin texto, logotipos, personas ni marcas de agua.

1K, 1:1, un intentoCopiar prompt

Prompt: jabón y toalla doblada

Pastilla rectangular de jabón crema junto a una toalla blanca doblada sobre una base azul pálido. Vista de tres cuartos y luz suave desde la izquierda para mostrar bordes lisos y bucles del tejido. Ambos objetos completos, en una composición despejada. Sin texto, logotipos, personas ni marcas de agua.

2K, 1:1, un intentoCopiar prompt

Prompt: jabón en una jabonera de vidrio

Jabón rectangular crema sobre una jabonera de vidrio transparente, junto a pliegues suaves de una toalla blanca y fondo azul pálido. Vista de tres cuartos, luz de la izquierda, borde fino del vidrio y reflejos visibles. El conjunto entero queda al centro con espacio alrededor. Sin texto, logotipos, personas ni marcas de agua.

4K, 1:1, un intentoCopiar prompt

05¿Cómo pones un tope al gasto?

El límite mensual de gasto es opcional y, por defecto, no existe. Se fija para la cuenta, en «Saldo y recargas» del portal, o para una clave, en «Claves de API», y los dos funcionan a la vez (Límites). Cuando se agota uno de los dos, la siguiente solicitud de generación recibe 402 ERR_INSUFFICIENT_BALANCE y no se hace ningún cargo (Claves y acceso).

El mismo 402 llega si el saldo no alcanza. Recárgalo en «Saldo y recargas» del portal o a través de un gestor de cuenta (Recarga en USDT).

06¿Qué no cubre este artículo?

• 10 000 es un volumen supuesto. No es el tráfico de Rendergrid ni el de una cuenta: sustitúyelo por el tuyo.
• Ningún porcentaje de fallos. El artículo cuenta imágenes terminadas y no estima qué parte de las solicitudes falla.
• Tres imágenes no son una comparativa. Son tres prompts distintos, con un intento cada uno: no miden calidad.
• Precios sin impuestos. Los precios no incluyen impuestos, y una subida se avisa con al menos 7 días de antelación (Condiciones de uso).

07¿Cómo calcular tu propio presupuesto?

La plantilla lee de GET /models el precio de tu cuenta, toma variants[].price y lo multiplica por tus cantidades. El curl solo consulta los precios. Python usa Decimal y Node.js, enteros en diezmilésimas de dólar, porque los números de coma flotante no son adecuados para importes (Saldo).

curl --fail-with-body --max-time 20 \
  "https://api.rendergrid.io/api/public/v1/models?category=image" \
  -H "Authorization: Bearer $RENDERGRID_API_KEY"

import os
from decimal import Decimal

import requests

API = "https://api.rendergrid.io/api/public/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['RENDERGRID_API_KEY']}"}

# Tus cantidades al mes: (modelo, resolución) -> imágenes terminadas.
# Al generar, envía siempre resolution: sin ese campo se cobra la resolución
# predeterminada del modelo.
PLAN = {
    ("nano-banana-flash", "1K"): 6000,
    ("nano-banana-2.1", "2K"): 3000,
    ("nano-banana-pro", "4K"): 1000,
}

response = requests.get(
    f"{API}/models",
    params={"category": "image"},
    headers=HEADERS,
    timeout=(5, 20),
)
response.raise_for_status()

# El precio de cada resolución sale de variants, nunca del price raíz
prices = {}
for model in response.json()["models"]:
    for variant in model.get("variants", []):
        key = (model["id"], variant["variant_key"].upper())
        prices[key] = Decimal(variant["price"])

total = Decimal("0")
for (model, resolution), images in PLAN.items():
    if (model, resolution) not in prices:
        raise SystemExit(f"Sin precio para {model} en {resolution}")
    subtotal = images * prices[(model, resolution)]
    total += subtotal
    print(model, resolution, images, subtotal)

print("Total al mes (USD):", total)

// Node.js 22+, archivo .mjs
const API = "https://api.rendergrid.io/api/public/v1";
const headers = { Authorization: `Bearer ${process.env.RENDERGRID_API_KEY}` };

// Tus cantidades al mes: modelo, resolución e imágenes terminadas.
// Al generar, envía siempre resolution: sin ese campo se cobra la resolución
// predeterminada del modelo.
const plan = [
  { model: "nano-banana-flash", resolution: "1K", images: 6000n },
  { model: "nano-banana-2.1", resolution: "2K", images: 3000n },
  { model: "nano-banana-pro", resolution: "4K", images: 1000n },
];

// El precio llega como cadena: pásalo a enteros en diezmilésimas de dólar, sin Number
function toUnits(price) {
  const [whole, fraction = ""] = price.split(".");
  if (fraction.length > 4) throw new Error(`Precio con más de 4 decimales: ${price}`);
  return BigInt(whole + fraction.padEnd(4, "0"));
}

const response = await fetch(`${API}/models?category=image`, {
  headers,
  signal: AbortSignal.timeout(20_000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const { models } = await response.json();

// El precio de cada resolución sale de variants, nunca del price raíz
const prices = new Map();
for (const model of models) {
  for (const variant of model.variants ?? []) {
    prices.set(`${model.id}:${variant.variant_key.toUpperCase()}`, toUnits(variant.price));
  }
}

let total = 0n;
for (const { model, resolution, images } of plan) {
  const price = prices.get(`${model}:${resolution}`);
  if (price === undefined) throw new Error(`Sin precio para ${model} en ${resolution}`);
  total += images * price;
}
const dollars = `${total / 10000n}.${String(total % 10000n).padStart(4, "0")}`;
console.log("Total al mes (USD):", dollars);

08Preguntas frecuentes

09Fuentes

1. Documentación de Rendergrid: modelos y parámetrosPrecio y resolución predeterminada.
2. Documentación de Rendergrid: saldoEl cargo y las solicitudes fallidas.
3. Documentación de Rendergrid: códigos de errorLos dos tipos de fallo.
4. Documentación de Rendergrid: límitesLímites mensuales de gasto.
5. Documentación de Rendergrid: recarga en USDTCómo recargar el saldo.
6. Precios de RendergridPrecio de cada modelo y resolución.
7. Condiciones de uso de RendergridImpuestos y subidas de precios.