250 clips on Black Friday: jobs Sume accepts at once

At the default settings a Sume workspace accepts this many paid generation jobs at once, counting both the ones processing and the ones queued: Free 6, Pro 24, Startup 48, Scale and Enterprise 120. The 25th submission on Pro returns 429 queue_full. So 250 clips on a Pro workspace cannot go in as one burst; they go in as waves that follow the queue.

Queued is not an error. Sume accepts valid jobs as queued while capacity remains, and workers move them into processing as concurrency slots open. Concurrency is a dispatch limit, not a submit limit.

Capacity by plan

From the Sume generation-admission docs. The dashboard Concurrency tab is the source of truth for your workspace, and generation_limits on a submit response gives the live numbers.

A waves script

The wave_size_hint (with an empty queue) is max(1, floor(queue_capacity_remaining x 0.75)). It is a hint for how many to submit in one wave, not a concurrency limit. This script sends waves of 15, which fits under the Pro hint of 18, and waits for each wave to reach a terminal state before it sends the next. It stores nothing, so in production keep each job id and its idempotency key.

import asyncio, os
import httpx

WAVE = 15
BASE = "https://api.sume.com"

async def terminal(client, job_id):
    while True:
        s = (await client.get(f"{BASE}/v1/videos/{job_id}")).json()
        if s["status"] in ("completed", "failed", "cancelled"):
            return s["status"]
        await asyncio.sleep(15)

async def submit(client, i):
    r = await client.post(f"{BASE}/v1/videos", headers={"Idempotency-Key": f"bf-2026-clip-{i}"},
        json={"model": "wan-3.0", "prompt": f"Product shot {i}", "duration": 6,
              "resolution": "720p", "aspect_ratio": "9:16"})
    r.raise_for_status()
    return r.json()["id"]

async def main():
    headers = {"Authorization": f"Bearer {os.environ['SUME_API_KEY']}"}
    async with httpx.AsyncClient(headers=headers, timeout=60) as client:
        for start in range(0, 250, WAVE):
            ids = await asyncio.gather(*(submit(client, i) for i in range(start, min(start + WAVE, 250))))
            print(start, await asyncio.gather(*(terminal(client, j) for j in ids)))

asyncio.run(main())

If you hit queue_full anyway

Do not add more work for that workspace. Poll until at least one job is terminal, cancel queued jobs you no longer need, and retry with the same idempotency key. Cancel works only before generation starts; after that it returns 409 job_generation_already_started. A failed admission releases its reservation.

Also budget the credits. A submit with too few credits to reserve gets 402 insufficient_credits before any work starts, with required_credits and available_credits in details. Check the balance on Thursday, not on Friday morning.

• Never resubmit a paid request only because your client timed out; use the same key.
• Plan concurrency does not rise with purchased credits.
• Poll with backoff, not in a tight loop.