Nano Banana Pro API

Nano Banana Pro is the higher-quality image model for professional creative production, commercial visuals, and precise image transformation.

Model keys

google/nano-banana-pro — Nano Banana Pro

Supported modes and inputs

Model	Mode	Label	Input requirements
`google/nano-banana-pro`	`text_to_image`	Text to Image	Prompt max 10000 chars
`google/nano-banana-pro`	`image_to_image`	Image to Image	Prompt max 10000 chars Images `reference`: 1-8 files, 30 MB, formats jpg, jpeg, png, webp

Options

Model	Option	Default	Allowed values	Applies to
`google/nano-banana-pro`	`aspect_ratio`	`1:1`	`1:1`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `16:9`, `21:9`, `auto`	All modes
`google/nano-banana-pro`	`resolution`	`1K`	`1K`, `2K`, `4K`	All modes
`google/nano-banana-pro`	`output_format`	`png`	`png`, `jpg`	All modes

Pricing

Model	Pricing
`google/nano-banana-pro`	2 credits per image

Production guidance

Pass mode explicitly.
Use only option values listed above.
Upload media with POST /api/v1/files before calling media-input modes.
Use the exact model key for the variant you want.

Example: text to image

curl https://img2vid.net/api/v1/generations \
  -H "Authorization: Bearer $BUBLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/nano-banana-pro",
    "mode": "text_to_image",
    "prompt": "A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting",
    "aspect_ratio": "1:1",
    "resolution": "1K",
    "output_format": "png"
  }'

Example: image to image

Upload an image first, then pass the returned URL to image_urls.

curl https://img2vid.net/api/v1/generations \
  -H "Authorization: Bearer $BUBLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/nano-banana-pro",
    "mode": "image_to_image",
    "prompt": "Transform the source into a clean commercial product image while preserving the main object",
    "image_urls": ["https://example.com/source.png"],
    "aspect_ratio": "1:1",
    "resolution": "1K",
    "output_format": "png"
  }'

SDK examples

The examples below use this page's public model key, mode, and parameter values. They assume you have already initialized the SDK client as shown in the Quickstart and imported the required language SDK types. For media-input modes, upload local files first and pass the returned URL through public fields such as image_urls, start_frame, or video_urls.

JavaScript / TypeScript

const task = await buble.generations.create({
  model: 'google/nano-banana-pro',
  mode: 'text_to_image',
  prompt:
    'A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting',
  aspect_ratio: '1:1',
  resolution: '1K',
  output_format: 'png',
});

const result = await buble.generations.wait(task.data.id);
console.log(result.data.result?.images?.[0]?.url);

Python

task = client.generations.create(
    model="google/nano-banana-pro",
    mode="text_to_image",
    prompt="A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting",
    aspect_ratio="1:1",
    resolution="1K",
    output_format="png",
)

result = client.generations.wait(task["data"]["id"])
print(result["data"]["result"]["images"][0]["url"])

Go

task, err := client.Generations.Create(ctx, &buble.CreateGenerationRequest{
	Model:  "google/nano-banana-pro",
	Mode:   "text_to_image",
	Prompt: "A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting",
	Params: map[string]any{
		"aspect_ratio": "1:1",
		"resolution": "1K",
		"output_format": "png",
	},
})
if err != nil {
	return err
}

result, err := client.Generations.Wait(ctx, task.Data.ID)
if err != nil {
	return err
}
fmt.Println(result.Data.Result.Images[0].URL)

Rust

let task = client.generations().create(
    CreateGenerationRequest::new("google/nano-banana-pro")
        .mode("text_to_image")
        .prompt("A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting")
        .param("aspect_ratio", "1:1")?
        .param("resolution", "1K")?
        .param("output_format", "png")?,
).await?;

let result = client
    .generations()
    .wait(&task.data.id, WaitOptions::default())
    .await?;

Swift

let task = try await client.generations.create(
    try CreateGenerationRequest(model: "google/nano-banana-pro")
        .mode("text_to_image")
        .prompt("A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting")
        .param("aspect_ratio", "1:1")
        .param("resolution", "1K")
        .param("output_format", "png")
)

let result = try await client.generations.wait(task.data.id)
print(result.data.result?.images?.first?.url.absoluteString ?? "")

Dart / Flutter

final task = await client.generations.create(
  CreateGenerationRequest(
    model: 'google/nano-banana-pro',
    mode: 'text_to_image',
    prompt: 'A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting',
  ).withParam('aspect_ratio', '1:1').withParam('resolution', '1K').withParam('output_format', 'png'),
);

final result = await client.generations.wait(task.data.id);
print(result.data.result?.images.firstOrNull?.url);

Elixir

{:ok, task} =
  Buble.Generations.create(client, %{
    model: "google/nano-banana-pro",
    mode: "text_to_image",
    prompt: "A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting",
    aspect_ratio: "1:1",
    resolution: "1K",
    output_format: "png"
  })

{:ok, result} = Buble.Generations.wait(client, task["data"]["id"])
IO.puts(result["data"]["result"]["images"] |> List.first() |> Map.fetch!("url"))

Java

Envelope<GenerationTask> task = client.generations().create(
        CreateGenerationRequest.builder()
                .model("google/nano-banana-pro")
                .mode("text_to_image")
                .prompt("A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting")
                .param("aspect_ratio", "1:1")
                .param("resolution", "1K")
                .param("output_format", "png")
                .build());

Envelope<GenerationTask> result = client.generations().wait(task.getData().getId());

.NET

var task = await client.Generations.CreateAsync(new CreateGenerationRequest
{
    Model = "google/nano-banana-pro",
    Mode = "text_to_image",
    Prompt = "A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting"
}.WithParam("aspect_ratio", "1:1").WithParam("resolution", "1K").WithParam("output_format", "png"));

var result = await client.Generations.WaitAsync(task!.Data!.Id!);

PHP

$task = $client->generations()->create(
    CreateGenerationRequest::make(
        model: 'google/nano-banana-pro',
        mode: 'text_to_image',
        prompt: 'A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting',
    )
    ->withParam('aspect_ratio', '1:1')
    ->withParam('resolution', '1K')
    ->withParam('output_format', 'png')
);

$result = $client->generations()->wait($task['data']['id']);

Ruby

task = client.generations.create(
  model: "google/nano-banana-pro",
  mode: "text_to_image",
  prompt: "A premium editorial product image of a minimalist ceramic coffee grinder on a warm walnut counter, soft studio lighting",
  aspect_ratio: "1:1",
  resolution: "1K",
  output_format: "png"
)

result = client.generations.wait(task.dig("data", "id"))
puts result.dig("data", "result", "images", 0, "url")