Batch image generation API: queue, webhooks, safe retries

import os
import threading
import time
from concurrent.futures import ThreadPoolExecutor

import requests

API = "https://api.rendergrid.io/api/public/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['RENDERGRID_API_KEY']}"}
MAX_IN_FLIGHT = 50  # your own cap, below the account's 100 queued or processing tasks
SUBMIT_GAP = 0.6  # seconds between starts: at most 100 requests a minute, below 120
DEADLINE = 600  # seconds to follow one task; a setting of this example, not a model time

pace_lock = threading.Lock()
last_start = 0.0


def pace():
    global last_start
    with pace_lock:
        pause = last_start + SUBMIT_GAP - time.monotonic()
        if pause > 0:
            time.sleep(pause)
        last_start = time.monotonic()


def run_job(job):
    job_id, prompt = job
    headers = {**HEADERS, "X-Idempotency-Key": f"catalog-{job_id}-v1"}
    payload = {"model": "nano-banana-2.1", "prompt": prompt, "resolution": "1K"}
    for _ in range(5):
        pace()
        resp = requests.post(
            f"{API}/images/generate", headers=headers, json=payload, timeout=(5, 30)
        )
        if resp.status_code != 429:
            break
        wait = resp.headers.get("Retry-After", "")
        time.sleep(int(wait) if wait.isascii() and wait.isdigit() else 2)
    if resp.status_code != 202:
        return job_id, {"id": None, "status": f"HTTP {resp.status_code}"}
    task_id = resp.json()["id"]
    stop = time.monotonic() + DEADLINE
    while time.monotonic() < stop:
        time.sleep(5)
        check = requests.get(
            f"{API}/creations/{task_id}", headers=HEADERS, timeout=(5, 20)
        )
        if check.status_code == 200 and check.json()["status"] in ("completed", "failed"):
            return job_id, check.json()
    return job_id, {"id": task_id, "status": "unresolved"}  # keep the id, look again later


# jobs: (your job ID, prompt) pairs from your own list
jobs = [("0001", "A plain white tube on a peach stage, soft light from the left")]

with ThreadPoolExecutor(max_workers=MAX_IN_FLIGHT) as pool:
    for job_id, task in pool.map(run_job, jobs):
        print(job_id, task["id"], task["status"])

// Node.js 22+, .mjs file
const API = "https://api.rendergrid.io/api/public/v1";
const AUTH = { Authorization: `Bearer ${process.env.RENDERGRID_API_KEY}` };
const MAX_IN_FLIGHT = 50; // your own cap, below the account's 100 queued or processing tasks
const SUBMIT_GAP_MS = 600; // between starts: at most 100 requests a minute, below 120
const DEADLINE_MS = 600_000; // a setting of this example, not a model time
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

let nextStart = 0;
async function pace() {
  const now = Date.now();
  const start = Math.max(now, nextStart);
  nextStart = start + SUBMIT_GAP_MS;
  await sleep(start - now);
}

async function runJob([jobId, prompt]) {
  const headers = {
    ...AUTH,
    "Content-Type": "application/json",
    "X-Idempotency-Key": `catalog-${jobId}-v1`,
  };
  const body = JSON.stringify({ model: "nano-banana-2.1", prompt, resolution: "1K" });
  let resp;
  for (let attempt = 0; attempt < 5; attempt++) {
    await pace();
    resp = await fetch(`${API}/images/generate`, {
      method: "POST",
      headers,
      body,
      signal: AbortSignal.timeout(30_000),
    });
    if (resp.status !== 429) break;
    const wait = resp.headers.get("Retry-After") ?? "";
    await sleep((/^[0-9]+$/.test(wait) ? Number(wait) : 2) * 1_000);
  }
  if (resp.status !== 202) return [jobId, { id: null, status: `HTTP ${resp.status}` }];
  const { id } = await resp.json();
  const stop = Date.now() + DEADLINE_MS;
  while (Date.now() < stop) {
    await sleep(5_000);
    const check = await fetch(`${API}/creations/${id}`, {
      headers: AUTH,
      signal: AbortSignal.timeout(20_000),
    });
    if (check.ok) {
      const task = await check.json();
      if (task.status === "completed" || task.status === "failed") return [jobId, task];
    }
  }
  return [jobId, { id, status: "unresolved" }]; // keep the id, look again later
}

// jobs: [your job ID, prompt] pairs from your own list
const jobs = [["0001", "A plain white tube on a peach stage, soft light from the left"]];
const waiting = [...jobs];
const results = [];
const workers = Array.from({ length: MAX_IN_FLIGHT }, async () => {
  for (let job = waiting.shift(); job; job = waiting.shift()) {
    results.push(await runJob(job));
  }
});
await Promise.all(workers);
for (const [jobId, task] of results) console.log(jobId, task.id, task.status);

import hashlib
import hmac
import os
import re
import time

from flask import Flask, request

app = Flask(__name__)
SECRET = os.environ["WEBHOOK_SECRET"]  # the signing secret from the portal, whsec_…
TOLERANCE_SECONDS = 300
handled = set()
inbox = []  # use a durable queue or a database in real use


def signature_ok(timestamp: str, raw_body: bytes, signature: str) -> bool:
    if not re.fullmatch(r"[0-9]{1,12}", timestamp):
        return False
    if not re.fullmatch(r"sha256=[0-9a-f]{64}", signature):
        return False
    if abs(time.time() - int(timestamp)) > TOLERANCE_SECONDS:
        return False
    expected = "sha256=" + hmac.new(
        SECRET.encode("utf-8"),
        timestamp.encode("ascii") + b"." + raw_body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature)


@app.post("/webhooks/rendergrid")
def receive():
    raw = request.get_data()
    timestamp = request.headers.get("X-Timestamp", "")
    signature = request.headers.get("X-Webhook-Signature-256", "")
    if not signature_ok(timestamp, raw, signature):
        return "", 401
    event = request.get_json(force=True)
    if event.get("test") is True:
        return "", 200  # the portal's test delivery: nothing to process
    once = (event["id"], event["event"])
    if once not in handled:
        inbox.append(event)  # save first, respond after
        handled.add(once)
    return "", 200

// Node.js 22+, .mjs file; npm install express
import { createHmac, timingSafeEqual } from "node:crypto";
import express from "express";

const SECRET = process.env.WEBHOOK_SECRET; // the signing secret from the portal, whsec_…
const TOLERANCE_SECONDS = 300;
const handled = new Set();
const inbox = []; // use a durable queue or a database in real use

function signatureOk(timestamp, rawBody, signature) {
  if (!/^[0-9]{1,12}$/.test(timestamp ?? "")) return false;
  if (!/^sha256=[0-9a-f]{64}$/.test(signature ?? "")) return false;
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > TOLERANCE_SECONDS) return false;
  const expected =
    "sha256=" +
    createHmac("sha256", Buffer.from(SECRET, "utf8"))
      .update(`${timestamp}.`, "ascii")
      .update(rawBody)
      .digest("hex");
  return timingSafeEqual(Buffer.from(expected, "ascii"), Buffer.from(signature, "ascii"));
}

const app = express();
app.post("/webhooks/rendergrid", express.raw({ type: "application/json" }), (req, res) => {
  const raw = req.body;
  const timestamp = req.get("X-Timestamp");
  const signature = req.get("X-Webhook-Signature-256");
  if (!Buffer.isBuffer(raw) || !signatureOk(timestamp, raw, signature)) {
    return res.sendStatus(401);
  }
  const event = JSON.parse(raw.toString("utf8"));
  if (event.test === true) return res.sendStatus(200); // the portal's test delivery
  const once = `${event.id}:${event.event}`;
  if (!handled.has(once)) {
    inbox.push(event); // save first, respond after
    handled.add(once);
  }
  return res.sendStatus(200);
});
app.listen(8080);

# The key stays the same for every repeat of this job. If you get no response, run this exact command again.
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: catalog-0412-v1" \
  -d '{
    "model": "nano-banana-2.1",
    "prompt": "A plain white tube on a peach stage, soft light from the left",
    "resolution": "1K"
  }'

import os
import random
import time

import requests

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


def submit(job_id: str, prompt: str, max_attempts: int = 3) -> dict:
    # one key per job: the same on every attempt, new only for a new image
    headers = {**HEADERS, "X-Idempotency-Key": f"catalog-{job_id}-v1"}
    payload = {"model": "nano-banana-2.1", "prompt": prompt, "resolution": "1K"}
    for attempt in range(max_attempts):
        last = attempt + 1 == max_attempts
        delay = 2 ** (attempt + 1) + random.random()
        try:
            resp = requests.post(
                f"{API}/images/generate", headers=headers, json=payload, timeout=(5, 30)
            )
        except (requests.Timeout, requests.ConnectionError):
            if last:
                raise
        else:
            if resp.status_code == 202:
                return resp.json()
            try:
                reason = resp.json()["error"]["details"]["reason"]
            except (ValueError, KeyError, TypeError):
                reason = ""
            retryable = resp.status_code in (429, 500, 503) and reason != "burst_block"
            if not retryable or last:
                raise RuntimeError(resp.status_code, resp.text)
            wait = resp.headers.get("Retry-After", "")
            if wait.isascii() and wait.isdigit():
                delay = max(delay, int(wait))
        time.sleep(delay)


creation = submit("0412", "A plain white tube on a peach stage, soft light from the left")
print(creation["id"], creation["status"], creation["cost"])

// Node.js 22+, .mjs file
const API = "https://api.rendergrid.io/api/public/v1";
const KEY = process.env.RENDERGRID_API_KEY;
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function submit(jobId, prompt, maxAttempts = 3) {
  // one key per job: the same on every attempt, new only for a new image
  const headers = {
    Authorization: `Bearer ${KEY}`,
    "Content-Type": "application/json",
    "X-Idempotency-Key": `catalog-${jobId}-v1`,
  };
  const body = JSON.stringify({ model: "nano-banana-2.1", prompt, resolution: "1K" });
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const last = attempt + 1 === maxAttempts;
    let delay = (2 ** (attempt + 1) + Math.random()) * 1_000;
    let resp;
    try {
      resp = await fetch(`${API}/images/generate`, {
        method: "POST",
        headers,
        body,
        signal: AbortSignal.timeout(30_000),
      });
    } catch (error) {
      const network = error instanceof TypeError;
      if (!network && error.name !== "TimeoutError") throw error;
      if (last) throw error;
    }
    if (resp) {
      if (resp.status === 202) return resp.json();
      const text = await resp.text();
      let reason;
      try {
        reason = JSON.parse(text)?.error?.details?.reason;
      } catch {
        reason = undefined;
      }
      const retryable = [429, 500, 503].includes(resp.status) && reason !== "burst_block";
      if (!retryable || last) throw new Error(`HTTP ${resp.status}: ${text}`);
      const wait = resp.headers.get("Retry-After");
      if (wait && /^[0-9]+$/.test(wait)) delay = Math.max(delay, Number(wait) * 1_000);
    }
    await sleep(delay);
  }
}

const creation = await submit("0412", "A plain white tube on a peach stage, soft light from the left");
console.log(creation.id, creation.status, creation.cost);