GPT Image 2.5 on Sume: the largest legal size for 21:9, 3:2 and 4:5

The largest 21:9 image you can ask GPT Image 2.5 for on Sume is 3840 x 1648 pixels, and a 4:1 banner is not allowed at all, because the model's custom sizes are capped at a 3:1 aspect ratio. The rule from Sume's Image API docs is that image_size takes custom pixels where both edges are multiples of 16, the longest edge is at most 3840, the aspect ratio is at most 3:1, and the total is between 655,360 and 8,294,400 pixels.

That matters this week because FLUX 3 Image advertises 21:9 to 9:21 and up to 4K. If you are comparing a wide-format job across models, GPT Image 2.5 can get close to 21:9 at near-4K width but not exactly the same pixel count, and it cannot do a ratio beyond 3:1.

The script

The function walks widths down from 3840 in steps of 16, derives the matching height, rounds it to a multiple of 16, rejects anything outside the ratio tolerance or the pixel band, and keeps the largest legal area. A 0.5 percent ratio tolerance is the default because most ratios cannot be hit exactly on a 16-pixel grid.

MAX_EDGE, MIN_PX, MAX_PX, MAX_ASPECT = 3840, 655_360, 8_294_400, 3.0

def largest_size(w_ratio, h_ratio, tol=0.005):
    target = h_ratio / w_ratio
    best = None
    for w in range(MAX_EDGE, 15, -16):
        h = round(w * target / 16) * 16
        if h < 16 or max(w, h) > MAX_EDGE:
            continue
        if abs(h / w - target) / target > tol:
            continue
        if max(w / h, h / w) > MAX_ASPECT or not MIN_PX <= w * h <= MAX_PX:
            continue
        if best is None or w * h > best[0] * best[1]:
            best = (w, h)
    return best

for r in [(16, 9), (21, 9), (3, 1), (4, 1), (3, 2), (4, 3), (4, 5), (9, 21)]:
    s = largest_size(*r)
    print(f"{r[0]}:{r[1]}", f"{s[0]}x{s[1]}" if s else "not legal")

What it prints

These are the outputs of the script as written, run on 2026-10-03. Note that 16:9 and 1:1 land exactly on the 8,294,400-pixel ceiling, while wide and tall ratios stay under it because the 3840-pixel edge limit binds first.

Using the size in a request

Send it as image_size on a model that accepts custom pixels, for example "image_size": {"width": 3840, "height": 1648} or the string "3840x1648". The docs say image_size wins over aspect_ratio, and that size is a tier shorthand and must not carry custom pixels. A request at these sizes is large and slow, so expect it to cross the 30-second wait and come back as a 202 job; the docs name 4K and high quality as the usual causes.

Round-trip the numbers once in your own code before a batch: assert both edges divide by 16, that the larger edge is at most 3840 and that the pixel total sits inside the band. It takes a few lines and turns a 400 into a local error you can read.

A size you compute is not a size the catalog confirms. Read supported_parameters from GET /v1/images/models for the model you pick, because a parameter the model does not list is rejected with 400 unsupported_parameter.

If you need 4:1 or wider

Pick a model that lists the ratio. Nano Banana 2 lists 4:1, 1:4, 8:1 and 1:8 in its aspect catalog; see Nano Banana 2 banner ratios. Otherwise generate at 3:1 and extend the canvas in your own tooling. For a pre-flight check of any size before you send it, the size validator post has the rule in code, and the Image API docs are the source for the limits.