API del fabricante o API unificada: cuándo ir directo

01¿Cómo comparamos las dos vías?

Aquí llamamos «API del fabricante» a la de Google o la de OpenAI usada directamente, y «API unificada» a la que reúne modelos de varios fabricantes con una sola clave, como la de Rendergrid. Comparamos el precio; de claves, límites y pago te decimos qué comprobar.

• Rendergrid, según su documentación. Claves, límites y pago salen de nuestras páginas de documentación.

• Los fabricantes, solo con datos publicados. Solo usamos los precios oficiales de Google; de OpenAI no usamos ningún precio, y de lo demás te decimos qué comprobar.

• Imágenes de Rendergrid. Las tres imágenes se hicieron a través de nuestra API: no hay ninguna ejecución directa en la API de un fabricante.

02¿Cuánto cuesta una imagen por cada vía?

Todos los precios de esta página son por imagen y están en dólares estadounidenses. En Rendergrid, Nano Banana 2.1 cuesta $0,02 en 1K, $0,03 en 2K y $0,04 en 4K; Nano Banana Pro, $0,04 en 1K, $0,04 en 2K y $0,07 en 4K. Una solicitud fallida es gratis: el importe vuelve de inmediato al saldo. Hay más modelos en la página de precios.

Precios oficiales de Google

Google publica el precio por imagen de los dos modelos, así que se puede comparar directamente con el de Rendergrid. Usamos su precio estándar, sin modo por lotes.

OpenAI también publica sus precios: el enlace está en las fuentes.

03¿Qué cambia con las claves y los límites?

En Rendergrid, una misma clave de API sirve para todos los modelos, de Google y de OpenAI. Una cuenta puede tener hasta 50 claves activas, pero el saldo y los límites son comunes a todas; por clave solo se fija un límite mensual de gasto, que es estricto: cuando se agota, la clave recibe un 402. Más en Claves y acceso.

Los límites son los mismos para cualquier cuenta: 120 solicitudes por minuto y 100 tareas en cola o en proceso a la vez. Añadir claves no los aumenta; si te quedan cortos, escribe a soporte. Si te llega un 429, lee el artículo sobre el error 429; las reglas completas están en Límites.

Para las claves y los límites de la API de Google o de OpenAI, consulta sus propias páginas de documentación.

04¿Cómo se paga en cada vía?

Rendergrid funciona con saldo prepago, que se recarga solo en USDT, en las redes Tron (TRC20), BNB Chain (BEP20) o Solana (SOL), desde la sección «Saldo y recargas» del portal o a través de un gestor de cuenta. Al saldo llega exactamente el importe que eliges: la comisión del servicio de pago es nuestra, y la comisión de red la paga la billetera desde la que envías. No hay suscripción.

El cargo se hace al aceptar la solicitud y, si la imagen no sale, vuelve solo al saldo. Los importes mínimos, por red, están en Recarga en USDT.

Para el pago en la API de Google o de OpenAI, consulta sus propias páginas.

05¿Qué resultado obtienes con una API unificada?

La API de Rendergrid responde primero con 202 y el id de la tarea; el resultado llega después en result_urls, enlaces que valen un día: guarda las imágenes en cuanto el estado sea completed. Estas tres son de Nano Banana 2.1 en 1K y 1:1, con un intento por prompt: una taza, un conjunto y otra taza sobre un fondo distinto. Muestran el tipo de resultado que obtienes, no que la API de un fabricante dé uno mejor ni peor.

Prompt: taza verde sobre fondo marfil

Una taza verde de cerámica sobre fondo continuo marfil, con el asa a la derecha. Cámara cerca de la altura del borde, en un ángulo leve. Luz suave de la izquierda y sombra corta para revelar pequeñas irregularidades del esmalte. Producto entero al centro y encuadre amplio. Sin texto, logotipos, personas ni marcas de agua.

1K, 1:1, un intentoCopiar prompt

Prompt: conjunto de cerámica verde

Conjunto de cerámica verde: taza, cuenco y plato sobre fondo continuo marfil. El plato queda acostado atrás, el cuenco a la izquierda y la taza a la derecha, casi sin superponerse. Luz suave desde la izquierda y esmalte del mismo tono. Muestra el conjunto completo. Sin texto, logotipos, personas ni marcas de agua.

1K, 1:1, un intentoCopiar prompt

Prompt: taza verde sobre terracota

Taza verde de cerámica con el asa a la derecha sobre fondo terracota pálido. Cámara a la altura del borde y luz suave de la izquierda. La sombra de una hoja aparece al lado, sin cruzar la taza. Encuadre sereno y amplio, producto completo. Sin texto, logotipos, personas ni marcas de agua.

1K, 1:1, un intentoCopiar prompt

En las tres el producto aparece entero y sin texto. En la segunda, el cuenco y la taza se solapan un poco con el borde del plato, y el plato se ve algo más claro que el cuenco y la taza, aunque el prompt pedía esmalte del mismo tono; en la tercera, la luz es más directa de lo que pedía el prompt.

06¿Cuándo conviene la API del fabricante?

Puede convenirte la API de Google o de OpenAI en estos casos; confírmalo en sus propias páginas.

A favor

• Necesitas máscaras o un tamaño exacto en píxeles. Rendergrid no admite máscaras ni los campos width y height: consulta las páginas del fabricante.
• No puedes pagar en USDT. Rendergrid solo se recarga en USDT: consulta cómo se paga en las páginas del fabricante.
• Necesitas un SLA. Rendergrid no tiene uno: consulta las condiciones del fabricante.
• Usas un solo fabricante y ya tienes su cuenta, su clave y su forma de pago. Pesa menos la ventaja de una sola clave y un solo saldo: compara solo el precio por imagen.
• El modelo que necesitas no está en Rendergrid. El catálogo de tu cuenta lo devuelve GET /models; hay más en Modelos y parámetros.

En contra

• Pierdes lo que ofrece Rendergrid. Una clave, un saldo y el mismo formato de solicitud para modelos de Google y de OpenAI.
• Hay que comparar claves, límites y pago. Consulta las páginas de cada fabricante y compáralas con las de Rendergrid.

07¿Cuándo conviene una API unificada?

Puede convenirte una API unificada, como la de Rendergrid, en estos casos.

A favor

• Usas modelos de Google y de OpenAI en el mismo producto. Una clave y un saldo cubren los dos, y cambiar de modelo es cambiar el campo model.
• Quieres que una solicitud fallida sea gratis. Si la imagen no sale, el cargo vuelve al saldo.
• Quieres ver el precio de cada imagen. El campo cost de la respuesta 202 lo trae.
• Quieres acotar el gasto por integración. Cada clave puede tener su límite mensual.

En contra

• Solo se recarga en USDT y no hay SLA.
• Los límites son por cuenta. Todas las claves comparten las mismas 120 solicitudes por minuto y 100 tareas simultáneas.
• Los resultados duran un día. Las imágenes las guardas tú.

Así se cambia de modelo: la misma solicitud, con otro valor en model.

# Hacen falta bash, curl y uuidgen.
IDEMPOTENCY_KEY="$(uuidgen)" || exit 1
curl --fail-with-body --max-time 30 \
  -X POST https://api.rendergrid.io/api/public/v1/images/generate \
  -H "Authorization: Bearer $RENDERGRID_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Idempotency-Key: $IDEMPOTENCY_KEY" \
  -d '{
    "model": "nano-banana-2.1",
    "prompt": "Una taza verde de cerámica sobre fondo marfil, luz suave de la izquierda",
    "resolution": "1K",
    "aspect_ratio": "1:1"
  }'

# Para Nano Banana Pro, repite la solicitud con "model": "nano-banana-pro"
# y una clave de idempotencia nueva. Después consulta la tarea con su id:
CREATION_ID="5b0214ae-9e39-460a-820a-f6ae3e24400b"  # el id de la respuesta 202
curl --fail-with-body --max-time 20 \
  "https://api.rendergrid.io/api/public/v1/creations/$CREATION_ID" \
  -H "Authorization: Bearer $RENDERGRID_API_KEY"

import os
import time
import uuid

import requests

API = "https://api.rendergrid.io/api/public/v1"
KEY = os.environ["RENDERGRID_API_KEY"]
PROMPT = "Una taza verde de cerámica sobre fondo marfil, luz suave de la izquierda"

for model in ("nano-banana-2.1", "nano-banana-pro"):
    response = requests.post(
        f"{API}/images/generate",
        headers={
            "Authorization": f"Bearer {KEY}",
            # una clave nueva en cada solicitud
            "X-Idempotency-Key": str(uuid.uuid4()),
        },
        json={
            "model": model,
            "prompt": PROMPT,
            "resolution": "1K",
            "aspect_ratio": "1:1",
        },
        timeout=(10, 120),
    )
    response.raise_for_status()
    job = response.json()
    while True:
        poll = requests.get(
            f"{API}/creations/{job['id']}",
            headers={"Authorization": f"Bearer {KEY}"},
            timeout=(5, 20),
        )
        poll.raise_for_status()
        creation = poll.json()
        if creation["status"] in ("completed", "failed"):
            break
        time.sleep(5)  # como máximo una consulta cada 5 segundos
    print(model, creation["status"], creation.get("result_urls"))

// Node.js 22+, archivo .mjs
import { randomUUID } from "node:crypto";

const API = "https://api.rendergrid.io/api/public/v1";
const key = process.env.RENDERGRID_API_KEY;
const prompt = "Una taza verde de cerámica sobre fondo marfil, luz suave de la izquierda";

for (const model of ["nano-banana-2.1", "nano-banana-pro"]) {
  const response = await fetch(`${API}/images/generate`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${key}`,
      "Content-Type": "application/json",
      // una clave nueva en cada solicitud
      "X-Idempotency-Key": randomUUID(),
    },
    body: JSON.stringify({ model, prompt, resolution: "1K", aspect_ratio: "1:1" }),
    signal: AbortSignal.timeout(120_000),
  });
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
  const job = await response.json();

  let creation;
  do {
    // como máximo una consulta cada 5 segundos
    await new Promise((resolve) => setTimeout(resolve, 5000));
    const poll = await fetch(`${API}/creations/${job.id}`, {
      headers: { Authorization: `Bearer ${key}` },
    });
    if (!poll.ok) {
      throw new Error(`HTTP ${poll.status}: ${await poll.text()}`);
    }
    creation = await poll.json();
  } while (["queued", "processing"].includes(creation.status));

  console.log(model, creation.status, creation.result_urls ?? creation.error);
}

{
  "id": "5b0214ae-9e39-460a-820a-f6ae3e24400b",
  "status": "queued",
  "task_id": "5b0214ae-9e39-460a-820a-f6ae3e24400b",
  "cost": 0.02
}

{
  "id": "5b0214ae-9e39-460a-820a-f6ae3e24400b",
  "status": "completed",
  "result_urls": [
    "https://…"
  ]
}

Usa una clave de idempotencia nueva en cada solicitud y la misma al repetirla: así un reintento no duplica el cargo. El paso a paso está en la guía de Nano Banana 2.1.

08¿Qué revisar antes de decidir?

• Precio. Mira el precio por imagen de tu modelo y tu resolución, en la tabla y en la página del fabricante.

• Claves. Cuenta cuántas claves y cuentas necesitarás.

• Límites. Compara los límites con tu volumen.

• Pago. Comprueba que puedes pagar como lo pide cada vía.

• Funciones. Mira si necesitas máscaras o un tamaño exacto en píxeles.

09¿Qué no cubre este artículo?

• De los fabricantes solo hay precios. Sus claves, límites y pagos no los comparamos: compruébalos en su documentación.
• Tres imágenes no son una medida. Un intento por prompt no dice nada de la calidad, la velocidad ni la fiabilidad.
• Las imágenes son de Rendergrid. No hubo ninguna ejecución directa en la API de un fabricante.
• Los límites son los predeterminados. Tu cuenta puede tener otros.

10Preguntas frecuentes

11Fuentes

1. Google AI for Developers: precios de la APIPrecio oficial por imagen: precio estándar, sin modo por lotes. Verificado el 26 de octubre de 2026.
2. OpenAI: precios de la APILista oficial de precios.
3. Precios de RendergridPrecio por imagen de cada modelo.
4. Claves y accesoDocumentación de Rendergrid.
5. LímitesDocumentación de Rendergrid.
6. Recarga en USDTDocumentación de Rendergrid.
7. SaldoDocumentación de Rendergrid.
8. Modelos y parámetrosDocumentación de Rendergrid.
9. Imágenes de este artículoResultados de Nano Banana 2.1 a través de Rendergrid.