Fastest Seedance or Kling model on Sume: latency labels

Which Seedance or Kling model is fastest on Sume?

seedance-2-fast and seedance-2-mini carry the fastest label in Sume's model cards. seedance-2 and seedance-2.5 are labelled medium, and kling-3 is labelled medium-slow. Those are the repo's own words for "typical latency" and they are relative ranks, not promised seconds.

The cards describe Fast as the speed-biased Seedance 2.0 row, with lower latency than seedance-2, and Mini as the cheapest 2.0 row, with cost as its strength.

Does the label tell me how many seconds to wait?

No. The video docs say generation typically takes from about 30 seconds to several minutes depending on model and parameters, and they suggest polling about every 30 seconds. Resolution, duration, audio and queue load all move the number, and a 30 second Seedance 2.5 clip is not the same wait as a 5 second Seedance 2.0 Mini clip even though both can be labelled by tier.

Treat the label as a way to choose between candidates, then measure your own request shape.

How do I time the models fairly?

Send the same prompt, duration, resolution and aspect ratio to each id and record the time from submit to completed. Keep audio the same on every run, since the audio setting is part of the request. Use 720p and a short duration so the test is cheap; each submit reserves the provider list price times 1.25 and the finished job reports usage.cost.

The script below submits to one model and prints the elapsed seconds. Run it once per model id. It refuses to start without a key.

import asyncio, os, sys, time
import httpx

async def main(model: str):
    key = os.environ.get("SUME_API_KEY")
    if not key:
        sys.exit("set SUME_API_KEY")
    body = {"model": model, "prompt": "A paper boat on a rainy street",
            "duration": 4, "resolution": "720p", "aspect_ratio": "16:9",
            "generate_audio": False}
    async with httpx.AsyncClient(headers={"Authorization": f"Bearer {key}"}, timeout=60) as c:
        t0 = time.monotonic()
        r = await c.post("https://api.sume.com/v1/videos", json=body)
        r.raise_for_status()
        url = r.json()["polling_url"]
        while True:
            await asyncio.sleep(10)
            s = (await c.get(url)).json()
            if s["status"] in ("completed", "failed", "cancelled"):
                break
        print(model, s["status"], round(time.monotonic() - t0), "s")

asyncio.run(main(sys.argv[1] if len(sys.argv) > 1 else "seedance-2-fast"))

What if I let Auto choose?

Auto does not help with a speed comparison. sume/auto picks the family for you and the response reports sume/auto; Sume does not disclose which family served the request. To compare Seedance and Kling you must pin ids.

If a job seems slow, read its events before blaming the model; the job events guide shows where time goes.

How should I choose between speed and the rest?

Draft on Fast or Mini at 480p or 720p, then render the keeper on the row you want to ship. seedance-2.5 is the one for clips beyond 15 seconds; kling-3 is the Kling row and it has no reference inputs. The price side of the same decision is in Seedance 2.5 versus Fast and Mini. Sume does not publish measured latency numbers, so the only reliable figure is the one you time yourself.