A CSV of prompts to a traceable set of image results

Bulk image generation API

Generate images in bulk by testing one image workflow, freezing it and supplying one row of variables per execution. For a 2,000-row CSV, process bounded batches and record each execution before moving on. Choose the available model and inspect its current price first. Reconcile uncertain runs instead of silently repeating paid generation.

Build this agent Read the recipe

How to generate images in bulk

Prepare and sample the CSV
Give each row a stable item ID and the inputs your image workflow requires. Test a small representative sample before submitting the full file. The 2,000 rows are a workload example, not a platform limit or throughput promise.
Choose and price the image step
Discover the currently available Nano Banana endpoint or another image model and read its input schema and price. Complete and review one generation before freezing the workflow with a matching input schema.
Use a bounded worker batch
The documented worker excerpt below calls one frozen compilation and returns its status, result and run ID. Initialize AgentClient and set your tested COMPILATION_ID as in the source. Adapt CSV fields to the actual frozen schema. Keep only a small batch in memory.
Record outputs and reconcile failures
Write each item ID, execution ID, status and output reference to your own durable manifest as it completes. Distinguish a confirmed failure from an unknown dispatch. Review paid retries explicitly; do not resubmit the whole CSV because a response was lost.

Documented one-row worker excerpt - source documentation

def process(row: dict) -> dict:
    result = client.compilations.run_instruction_and_wait(
        COMPILATION_ID,
        variables=row,
        timeout=600,
    )
    return {"row": row, "status": result.status, "output": result.output,
            "error": result.error, "run_id": result.id}

This is the worker function from the parallel-runs guide, not a complete CSV program. Its client and COMPILATION_ID are initialized in that guide. The example worker count is not an account concurrency guarantee.

What you get

Illustrative output - example data

item_id,execution_id,status,output_reference
image-0001,example-run-1,completed,returned-image-reference
image-0002,example-run-2,needs-review,no-automatic-resubmission

Where the result goes

Persist output references and execution IDs in a manifest you control. Download or send completed images only through a configured destination. Avoid keeping thousands of image payloads in one request or agent response.

Cost and operating limits

Total usage depends on the chosen model, inputs and accepted generation attempts. Verify price before the sample and review the sample cost before scaling. [[FACT NEEDED: verified Nano Banana input schema, current batch concurrency allowance and throughput for the target account.]]

Check current pricing

Choose the right approach

Implementation choices for this job
Approach	What to evaluate
A frozen image agent	Useful when each row needs validated preparation, generation and an explicit output step.
Direct model API calls	Useful when each row is already a complete model request and you operate concurrency, idempotency and storage yourself.
One giant agent request	A large combined response is harder to reconcile and can hold too much data in memory. Prefer a bounded manifest-driven job.

Frequently asked questions

Can I submit 2,000 rows at once?

This guide does not establish an account limit or one-request batch endpoint. Use bounded batches after checking your available concurrency and model contract.

Are failed or repeated generations free?

Do not assume that. Check the documented outcome and billing for the selected model; reconcile unknown executions before repeating a paid operation.

Can I use Nano Banana?

Discover the currently available endpoint and its schema and price. The operating guide lists Nano Banana, but a concrete bulk workflow still needs its own verified sample.