250 Nano Banana 2.1 images: Google standard vs batch vs Sume, 1K to 4K

For 250 Nano Banana 2.1 images, Google's own price page gives $8.40 at 1K, $12.60 at 2K and $28.25 at 4K on the standard tier, and half of that on batch: $4.20, $6.30 and $14.175. Sume lists the model at $0.10, $0.15 and $0.20 per image for the same sizes, so 250 images cost $25.00, $37.50 and $50.00. Sume's docs describe no batch discount: there is one price per size.

The arithmetic

Google's per-image prices on the Gemini API pricing page, read 2026-10-09, are $0.0336 (1K), $0.0504 (2K) and $0.113 (4K) for standard, and $0.0168, $0.0252 and $0.0567 for batch. Multiply by 250. Sume's per-image prices are from its price list. The script uses Decimal so that the 4K batch figure comes out as $14.175 and not a float with a long tail.

Reading the table fairly

Google's prices are model-provider prices for calling Google's API directly. Sume gives you one bearer-key API and one balance across its models, and Google gives you its own account and quota. The prices are not directly comparable as a service, and this post does not claim that either one is the better buy. The gap is widest at 1K, where Sume is about three times Google standard, and narrower at 4K, where it is 1.77 times.

Batch is a Google tier whose price is half of standard. If your 250 images are not time-sensitive, batch is the lowest number in the table. At 2K the gap to Sume is 37.50 - 12.60 = $24.90 against standard and 37.50 - 6.30 = $31.20 against batch. If you need an image back in the same HTTP call, Sume's POST /v1/images waits up to 30 seconds and returns 200 with the image, or 202 with a job to poll.

from decimal import Decimal as D

PER_IMAGE = {  # USD per image: Google (read 2026-10-09) and Sume list price
    "1K": {"google_standard": D("0.0336"), "google_batch": D("0.0168"), "sume": D("0.10")},
    "2K": {"google_standard": D("0.0504"), "google_batch": D("0.0252"), "sume": D("0.15")},
    "4K": {"google_standard": D("0.113"), "google_batch": D("0.0567"), "sume": D("0.20")},
}

def bill(n, tier):
    return {name: n * price for name, price in PER_IMAGE[tier].items()}

for tier in ("1K", "2K", "4K"):
    row = bill(250, tier)
    print(tier, {k: f"${v:.2f}" for k, v in row.items()})

Run it

The script prints three rows with dollar signs. Change 250 to your own count. To check the Sume column against the live API, read GET /v1/images/models/{id}/endpoints, whose pricing lines already include Sume's margin; you pay cost_usd times n.

Two cautions on the numbers. First, Google's page quotes prices per image for the sizes shown, and 1K, 2K and 4K there map to the same size names that Sume uses, but check the pixel dimensions you actually request. Second, 250 is a round example. The arithmetic scales linearly, so 1,000 images at 1K is 1,000 x 0.0336 = $33.60 on Google standard and 1,000 x 0.10 = $100.00 on Sume. Replace the count, keep the method.

• Pick the size first; it moves the bill more than the tier does.
• Use Decimal for money in code.
• Re-read Google's page before a large order, since prices move.