GPT Image 2.5 at 250 IPM with no Batch API: capacity planning for Bubble bulk catalogs via BIAIG

Context

Recent digest notes: GPT Image 2.5 (gpt-image-2.5-flare, gpt-image-2.5-sunburst) tops out at 250 images per minute (IPM) on the highest usage tier, and you should not plan Batch as the primary path for 2.5—model pages show a batch endpoint in the UI, but OpenAI’s Batch guide says to verify per-model support, and third-party write-ups (LaoZhang, Sept 2026) claim batch-priced image jobs list only gpt-image-2, not 2.5. That is not definitive; run one controlled Batch JSONL test or check OpenAI’s model matrix before you ship.

For Bubble bulk catalogs orchestrated via BIAIG (editorial context; Scout found no public docs under that acronym), the synchronous Images API becomes a capacity design problem, not just prompting. Worth reading next: gpt-image-1 sunsets 23 Oct 2026:. A closer look: bubble.io reviews for founders: a. Same topic: Fozzels October 2026: Image Flow. Same topic: Krea 3 Ultra: 2K edits.

What actually limits you (OpenAI)

Flare and Sunburst share the same tier table: 5 / 20 / 50 / 150 / 250 IPM (plus matching TPM). OpenAI states RPM, TPM, and IPM can bind independently; limits are org/project-scoped; models may share pools; on 429, honor Retry-After, use backoff with jitter, and separate rate limits from quota/billing errors.

n from 1–10 returns multiple images per request but does not bypass IPM and can worsen bursts if teams confuse “HTTP requests” with “catalog rows delivered.”

Planning variable (inference, not an SLA):

effective throughput ≈ min(IPM, concurrency_adjusted_for_latency, TPM_if_heavy) − retries − moderation − duplicate_after_timeout

Third-party Atlas Cloud (Sept 2026) suggests planning on the order of ~100 “usable” images with queue discipline and rework budget—not equating tier IPM with finished spreadsheet rows.

Bubble: parallelism ≠ IPM

Bubble does not publish a fixed concurrent API-workflow cap. Schedule API workflow on a list can run many jobs in parallel (not all at once); intervals reduce overlap but do not guarantee strict serialization. Workflows hard-timeout at 300 seconds.

Bubble explicitly recommends intervals to protect third-party API rate limits—firing 500 list-scheduled rows into immediate image calls without admission control often yields 429/slow_down; retry storms can still consume limit budget (OpenAI).

The editorial ~500-row chunk for bulk tools is product/editorial context, not a Bubble hard limit (docs reference very large list-schedule ceilings). Treat chunk size as operational safety, not proof that Bubble caps at 500.

Capacity plan for BIAIG (sync 2.5)

1. Find the binding constraint

• Confirm live IPM tier in the dashboard (may differ from model-page tables).
• Measure per-image latency (variant/quality); without that, concurrency math is guesswork.
• If prompts are token-heavy, watch TPM.
• Under load: does OpenAI IPM, Bubble scheduler congestion, or Workflow API RPM bind first?

2. Admission control in workflows

• Avoid 1:1 “spreadsheet row → instant image call” with no throttle.
• Patterns: list interval; semaphore (in-flight counter); recursive chunking (e.g. 100–500 rows + resumable state).
• Idempotency after timeouts—don’t double-submit without row status checks.

3. Retry policy (Scout + community summary of OpenAI error classes)

• Retry: transient 429 / overload with Retry-After.
• Do not auto-retry: quota/billing, moderation_blocked, image_generation_user_error—or rework and queues consume your window.

4. Fallback routing when Batch for 2.5 is unavailable

Route	When	Tradeoff
2.5 sync + IPM queue	Same-session catalog needing Flare/Sunburst	Full sync pricing; hard IPM cap
gpt-image-2 Batch	Overnight / cost-insensitive volume	50% Batch discount (OpenAI guide), up to 24h completion, one model per JSONL—not same-session UX unless the product supports async status
Other provider via BIAIG	Overflow	Only if BIAIG exposes routing (needs vendor confirmation)

Bubble’s Agnostic Agents Pro plugin shows multi-provider orchestration in workflows—pattern analog, not proof of BIAIG’s surface. Worth reading next: Batch API up to 50k.

Checklist: how many catalog rows per window

No guaranteed SLA—planning only.

1. Published ceiling (if IPM binds): rows_ceiling ≈ IPM × minutes_in_window—at Tier 5, ≤ 15,000 image completions/hour is theoretical only when each success equals one image and nothing else binds.
2. Conservative planning (third-party framing): for ops plans, consider ~40% of tier IPM as a usable anchor (Atlas cites ~100 at 250 IPM—not OpenAI official); replace with your measured rework rate.
3. Concurrency check: with mean latency L seconds and C in-flight calls, a rough bound is ≤ min(IPM, 60×C/L) successes/min—until you measure L, keep C low.
4. Bubble window: chunks ≤ ~500 rows; pause between chunks; persist resume keys (row id, attempt, last error class).
5. Pre-release: load-test 50–100 rows; track % 429, % moderation, median latency; update the plan table.

Open questions (don’t state as facts)

• Production Batch eligibility for gpt-image-2.5-flare / sunburst.
• Whether Flare and Sunburst share one IPM pool.
• Whether BIAIG supports Batch, async polling, or multi-provider fallback—requires primary vendor documentation.

Source boundary

OpenAI: 2.5 Flare/Sunburst and gpt-image-2 model pages; Rate limits, Batch, and Image generation guides. Bubble: Scheduling API workflows, Bulk operations compared, Hard limits, Scheduler. Planning color: Atlas Cloud, LaoZhang (Batch 2.5), CometAPI community (error classes). Editorial: digest IPM/batch absence; ~500-row chunking; BIAIG as orchestration layer. A closer look: Flare, Sunburst, and WaveSpeedAI: routing.