Cheapest 1080p Sume video model for 10, 12, 20 s: $1.875/$2.40/$5.00

At 1080p the cheapest listed Sume video model depends on the length, because the cheap models stop at different durations. For 10 seconds it is gemini-omni-flash-1.1 at 10 x 0.1875 = $1.875. For 12 seconds Gemini Omni is out of range (it stops at 10), so minimax-h3-max wins at 12 x 0.20 = $2.40. For 20 seconds only wan-3.0 and seedance-2.5 accept the length, and wan-3.0 costs 20 x 0.25 = $5.00.

Prices and ranges

Sume bills the provider list price times 1.25, and the per-second figures below already include that. minimax-h3 is left out because it tops out at 768p. Each row is linear in duration, so multiply the per-second price by the seconds.

Why filter by range, not just by price

A price table sorted by per-second cost puts gemini-omni-flash-1.1 first for every length, and that is wrong for 12 and 20 seconds. A submit with an unsupported duration is rejected, so the useful answer is the cheapest model that can take the request. The script reads GET /v1/videos/models, keeps the models whose supported_resolutions include 1080p and whose supported_durations include the requested length, and then sorts by price times seconds.

import json, os, urllib.request

PRICE_1080P = {"seedance-2.5": 1.42155, "seedance-2": 0.8505, "wan-3.0": 0.25,
               "minimax-h3-max": 0.20, "gemini-omni-flash-1.1": 0.1875}

def cheapest(seconds, resolution="1080p"):
    req = urllib.request.Request("https://api.sume.com/v1/videos/models",
                                 headers={"Authorization": "Bearer " + os.environ["SUME_API_KEY"]})
    with urllib.request.urlopen(req) as r:
        models = json.load(r)["data"]
    fits = [(round(PRICE_1080P[m["id"]] * seconds, 4), m["id"]) for m in models
            if m["id"] in PRICE_1080P
            and resolution in m["supported_resolutions"]
            and seconds in m["supported_durations"]]
    return min(fits) if fits else None

for s in (10, 12, 20):
    print(s, cheapest(s))

Reading the result

The 1080p price of minimax-h3-max is a latent refinement from native 768p, which is why it is cheaper than native-1080p models; its 768p price is $0.10 per second if that resolution is acceptable. Gemini Omni Flash 1.1 has native synced audio that you cannot turn off, so a silent edit needs another model. Cheapest here means cheapest list price, not best match for a prompt; the sample makes no claim about quality.

The price dictionary in the script is typed in by hand from the price list. When prices change, the dictionary goes stale before the endpoint does, so treat it as a cache and compare against the catalog now and then.

Two more lengths show the pattern. At 15 seconds Gemini Omni is still out of range, minimax-h3-max costs 15 x 0.20 = $3.00 and wan-3.0 costs 15 x 0.25 = $3.75. At 30 seconds only wan-3.0 and seedance-2.5 remain: 30 x 0.25 = $7.50 against 30 x 1.42155 = $42.6465. The cheapest answer changes at each limit, which is why the script filters before it sorts.

If you can accept a lower resolution, run the script again with resolution set to 720p and the 720p prices. For 10 seconds at 720p, gemini-omni-flash-1.1 is 10 x 0.125 = $1.25 and wan-3.0 is 10 x 0.125 = $1.25 as well, so the tie breaks on audio, aspect ratio and the references you need, not on price.

• Filter by supported_durations before you rank.
• Put resolution in the request; 1080p is not the default on every model.
• Check usage.cost on the first real job against your table.