任务与状态

CREATION_ID="5b0214ae-9e39-460a-820a-f6ae3e24400b"
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 requests

API = "https://api.rendergrid.io/api/public/v1"
creation_id = "5b0214ae-9e39-460a-820a-f6ae3e24400b"
key = os.environ["RENDERGRID_API_KEY"]
response = requests.get(
    f"{API}/creations/{creation_id}",
    headers={"Authorization": f"Bearer {key}"},
    timeout=(5, 20),
)
response.raise_for_status()
print(response.json())

// Node.js 22+，文件扩展名为 .mjs
const API = "https://api.rendergrid.io/api/public/v1";
const id = "5b0214ae-9e39-460a-820a-f6ae3e24400b";
const key = process.env.RENDERGRID_API_KEY;
const response = await fetch(`${API}/creations/${id}`, {
  headers: { Authorization: `Bearer ${key}` },
  signal: AbortSignal.timeout(20_000),
});
if (!response.ok) {
  const body = await response.text();
  throw new Error(`HTTP ${response.status}: ${body}`);
}
console.log(await response.json());

HTTP/1.1 429 Too Many Requests
Retry-After: 2

{
  "error": {
    "code": "ERR_RATE_LIMIT",
    "message": "polled too soon — retry after the minimum interval",
    "details": { "min_interval_seconds": 5 }
  }
}

import os
import time
import requests

BASE = "https://api.rendergrid.io/api/public/v1"
KEY = os.environ["RENDERGRID_API_KEY"]
SESSION = requests.Session()
SESSION.headers["Authorization"] = f"Bearer {KEY}"
TIMEOUT = (5, 20)  # 单位为秒：连接超时、读取超时


def wait_for(creation_id: str, wait_seconds: int = 180) -> dict:
    url = f"{BASE}/creations/{creation_id}"
    deadline = time.monotonic() + wait_seconds
    while time.monotonic() < deadline:
        delay = 5.0
        try:
            resp = SESSION.get(url, timeout=TIMEOUT)
        except (requests.Timeout, requests.ConnectionError):
            resp = None
        if resp is not None:
            if resp.status_code == 429 or resp.status_code >= 500:
                wait = resp.headers.get("Retry-After", "5")
                if wait.isascii() and wait.isdigit():
                    delay = max(5.0, int(wait))
            else:
                resp.raise_for_status()
                creation = resp.json()
                if creation["status"] in ("completed", "failed"):
                    return creation
        if delay >= deadline - time.monotonic():
            break
        time.sleep(delay)
    # 超时：id 已保存，之后可以继续轮询
    raise TimeoutError(f"Still unresolved: {creation_id}")

const BASE = "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 waitFor(creationId, waitMs = 180_000) {
  const url = `${BASE}/creations/${creationId}`;
  const deadline = Date.now() + waitMs;
  while (Date.now() < deadline) {
    let delay = 5_000;
    let resp;
    try {
      const left = Math.min(20_000, deadline - Date.now());
      resp = await fetch(url, {
        headers: { Authorization: `Bearer ${KEY}` },
        signal: AbortSignal.timeout(Math.max(1, left)),
      });
    } catch (error) {
      const network = error instanceof TypeError;
      if (!network && error.name !== "TimeoutError") throw error;
    }
    if (resp) {
      if (resp.status === 429 || resp.status >= 500) {
        const wait = resp.headers.get("Retry-After");
        if (wait && /^[0-9]+$/.test(wait)) {
          delay = Math.max(delay, Number(wait) * 1_000);
        }
      } else {
        if (!resp.ok) {
          const text = await resp.text();
          throw new Error(`HTTP ${resp.status}: ${text}`);
        }
        const creation = await resp.json();
        if (["completed", "failed"].includes(creation.status)) {
          return creation;
        }
      }
    }
    if (delay >= deadline - Date.now()) break;
    await sleep(delay);
  }
  // 超时：id 已保存，之后可以继续轮询
  throw new Error(`Still unresolved: ${creationId}`);
}