WaveSpeed polls at 2 seconds minimum; Sume: next_poll_after_seconds

WaveSpeedAI tells clients to start polling around 2 seconds, increase toward 5 to 10 seconds, and never poll faster than every 2 seconds. Sume's status endpoint can return next_poll_after_seconds, and the docs say a client must honor it when present and back off exponentially otherwise.

WaveSpeed's guidance is from its REST API docs and Sume's from Jobs and results and Webhooks, read 2026-10-02.

What is WaveSpeed's polling advice?

The page describes a three-step loop: POST the task, get a task id and a status URL, then GET /predictions/{TASK_ID}/result until the task finishes. The interval starts near 2 seconds and grows to 5 to 10 seconds. Anything faster than every 2 seconds is called out as something not to do. Documented error codes include 429 for rate limiting.

The page names a webhook verification route among its operations, but the part we fetched did not give webhook delivery details, so this post does not compare them.

What is Sume's polling contract?

Submit with mode: "async" and an Idempotency-Key. The response carries the job id, status_url, result_url and next_poll_after_seconds. Poll status_url and stop when terminal is true, then read result_url once result_ready is true.

If you would rather not poll, mode: "webhook" sends a signed terminal callback to a public HTTPS webhook_url. The docs still recommend keeping polling as a backup for missed deliveries.

What does a Sume loop look like?

This is the loop from the earlier posts, set to a 20-minute client-side deadline, which the docs call reasonable for video. It sleeps for the server hint when one is present and otherwise doubles up to 30 seconds.

import os, time, requests

H = {"Authorization": f"Bearer {os.environ['SUME_API_KEY']}"}
BASE = "https://api.sume.com/v1/jobs"

def wait(job_id, deadline_s=1200):
    end, delay = time.time() + deadline_s, 5
    while time.time() < end:
        r = requests.get(f"{BASE}/{job_id}/status", headers=H, timeout=30)
        r.raise_for_status()
        s = r.json()
        if s.get("terminal"):
            return s
        time.sleep(s.get("next_poll_after_seconds") or delay)
        delay = min(delay * 2, 30)
    raise TimeoutError(f"still running: {job_id}")

Which pace should you pick?

If a port keeps WaveSpeed's 2-second start, you will mostly burn requests: Sume's hint will usually be your better guide, and a rate-limited response carries retry-after. Sume sync mode waits at most 30 seconds on the submit call, so it only suits short jobs; for video use async or a webhook with polling as the fallback.