FLUX 3 Image cost per megapixel: why 2K is the cheapest tier

On BFL's published list prices, FLUX 3 Image is cheapest per megapixel at the 2k tier: about $0.025 per megapixel, against roughly $0.048 at 1k, $0.038 at 4k and $0.0695 at the small 768sq tier. The per-image price rises with size, but not in proportion to pixels, so the tier you pick changes your cost per pixel by almost a factor of three.

That is a calculation from BFL's own pricing page, not a measurement, and the megapixel counts are the approximate ones BFL uses in its tier names. Sume does not list FLUX 3 Image in the docs I read, so the figures here are for planning a BFL purchase or for comparing against Sume's per-image prices.

The numbers

BFL's pricing docs list four resolution names for FLUX 3 Image: 768sq (768 x 768), 1k (about 1 megapixel), 2k (about 4 megapixels) and 4k (about 16 megapixels). Dividing each price by its pixel count gives the table below.

What follows from it

The 768sq tier is a trap for cost-minded buyers. It is $0.007 cheaper than 1k per image but gives you about 40 percent fewer pixels, so each pixel costs nearly 45 percent more. If you only need a small image, it is still the cheapest ticket, but if you will upscale it later, you are paying a premium for a smaller starting point.

The jump from 2k to 4k is where the money goes. A 4k image costs 6.07 times a 2k image for four times the pixels. If the final asset is a 1080p or 1440p delivery file, 4k is paid-for resolution you will throw away. If it is a print or a large display, compare against generating at 2k and using an upscaler, which on Sume is the image_upscale_create tool listed in the MCP docs; check its quote before assuming it is cheaper.

BFL's FLUX.2 pricing uses a different shape: a flat first megapixel with each extra megapixel added on top, starting from $0.03 for Pro. That is why comparing FLUX 3 and FLUX 2 prices at one size tells you little; compare them at the size you ship.

Price a batch before you run it

Put the tiers in a dictionary and compute a batch total and a per-megapixel figure for whatever sizes you are considering. The script is plain Python and needs nothing installed.

Run as written, it prints the four rows above, then the cost of 200 images at 2k ($20.00) and at 4k ($121.40). That is the whole decision in two numbers: if 200 finished assets only need to be sharp at 1440p, the 4k run pays $101.40 for pixels nobody sees.

BFL's pricing calculator also offers a 1.5K option. The page I could read shows no separate price for it, so it is left out of the table rather than guessed.

# BFL FLUX 3 Image list prices (docs.bfl.ml pricing, read 2026-10-03)
TIERS = {"768sq": (768 * 768 / 1e6, 0.041), "1k": (1.0, 0.048), "2k": (4.0, 0.100), "4k": (16.0, 0.607)}

for name, (mp, usd) in TIERS.items():
    print(f"{name:>5}  ~{mp:5.2f} MP  ${usd:.3f}  ${usd / mp:.4f} per MP")

def batch_cost(tier, n, discount=1.0):
    return TIERS[tier][1] * n * discount

print(batch_cost("2k", 200), batch_cost("4k", 200))

Where Sume's pricing differs

Sume bills images per image, and each endpoint's pricing lines already include Sume's margin, so cost_usd multiplied by n is what you pay. Read them from GET /v1/images/models/{id}/endpoints rather than from a blog table. For the slow, large configurations the docs warn that 4K, high quality and large n are the ones most likely to run past the 30-second wait and come back as a 202 job.

If you are comparing against a Sume model for the same size, take the price from that endpoint's pricing lines and divide by the pixels you actually request. The Image API docs describe the endpoint records, and FLUX 3 price by tier versus Sume pricing lookup covers the lookup step.