# Gemini 3 Pro Image (`gemini-3-pro-image`)

## Overview
Nano Banana Pro is the flagship model for highest-quality rendering, complex multi-image fusion, character consistency, and sharp on-image typography.

> **Model ID note**: the earlier `gemini-3-pro-image-preview` was deprecated 2026-05-28 and shut down 2026-06-25. `gemini-3-pro-image` is the current generally-available (GA) replacement. Re-verify against [ai.google.dev/gemini-api/docs/image-generation](https://ai.google.dev/gemini-api/docs/image-generation) before relying on this ID, since Google rotates preview/GA model names on its own schedule.

## Model Specification
- **Model ID**: `gemini-3-pro-image`
- **API**: Interactions API (`client.interactions.create`) — this model does not use the older `generate_content` method.
- **Primary Use**: Premium graphics, multi-image fusion, dense on-image text, complex composite scenes.
- **Cost**: Billable per call. Quote the current price from the live [pricing page](https://ai.google.dev/gemini-api/docs/pricing) and get explicit user approval before every generation — see the skill's cost-approval rule.
- **Reference images**: Up to 14 supported as additional `image` input parts.
- **Reproducibility**: No `seed` parameter is documented for this model. Treat every generation as non-deterministic; for "same image but change X" requests, reuse the exact original prompt and reference images rather than promising an identical re-roll.

## Request Shape

### Python SDK (`google-genai`, Interactions API)
```python
from google import genai
import base64

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-pro-image",
    input="A high-end editorial magazine cover featuring a futuristic electric car with legible headline text 'THE FUTURE OF MOBILITY'",
    response_format={
        "type": "image",
        "aspect_ratio": "3:4",
        "image_size": "2K",
    },
)

with open("generations/cover.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))
```

### Multi-Image Reference & Fusion
Nano Banana Pro supports up to 14 reference images for composition and style fusion:
```python
from google import genai
import base64

client = genai.Client()

with open("generations/refs/brand/character.png", "rb") as f:
    subject_bytes = f.read()
with open("generations/refs/brand/logo.png", "rb") as f:
    logo_bytes = f.read()

interaction = client.interactions.create(
    model="gemini-3-pro-image",
    input=[
        {"type": "text", "text": "Combine the character from the first image and place the logo from the second image on their jacket in a retro synthwave city"},
        {"type": "image", "data": base64.b64encode(subject_bytes).decode("utf-8"), "mime_type": "image/png"},
        {"type": "image", "data": base64.b64encode(logo_bytes).decode("utf-8"), "mime_type": "image/png"},
    ],
    response_format={"type": "image", "aspect_ratio": "16:9", "image_size": "2K"},
)
```

### REST API (`curl`)
```bash
mkdir -p generations
cat > generations/pro_image_request.json << 'EOF'
{
  "model": "gemini-3-pro-image",
  "input": [
    {"type": "text", "text": "A high-end editorial magazine cover featuring a futuristic electric car with legible headline text 'THE FUTURE OF MOBILITY'"}
  ],
  "response_format": {
    "type": "image",
    "aspect_ratio": "3:4",
    "image_size": "2K"
  }
}
EOF

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @generations/pro_image_request.json > generations/pro_image_response.json
```

The response's `output_image.data` field holds the base64-encoded image bytes; decode and write them to the target file.

# Gemini 3.1 Flash Image (`gemini-3.1-flash-image`)

## Overview
Nano Banana 2 is the standard production model for image generation. It balances crisp detail, accurate style adherence, and high speed for most finished work.

## Model Specification
- **Model ID**: `gemini-3.1-flash-image`
- **API**: Interactions API (`client.interactions.create`) — this model does not use the older `generate_content` method.
- **Primary Use**: Production image generation, brand assets, social media graphics.
- **Cost**: Billable per call. Quote the current price from the live [pricing page](https://ai.google.dev/gemini-api/docs/pricing) and get explicit user approval before every generation — see the skill's cost-approval rule.
- **Reference images**: Up to 14 supported as additional `image` input parts.
- **Reproducibility**: No `seed` parameter is documented for this model. Treat every generation as non-deterministic; for "same image but change X" requests, reuse the exact original prompt and reference images rather than promising an identical re-roll.

## Request Shape

### Python SDK (`google-genai`, Interactions API)
```python
from google import genai
import base64

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.1-flash-image",
    input="A sleek modern product advertisement for wireless headphones on a clean marble table, studio lighting",
    response_format={
        "type": "image",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

with open("generations/headphones.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))
```

### Reference Image Input
```python
from google import genai
import base64

client = genai.Client()

with open("generations/refs/brand/style_sample.png", "rb") as f:
    style_bytes = f.read()

interaction = client.interactions.create(
    model="gemini-3.1-flash-image",
    input=[
        {"type": "text", "text": "Generate a pricing page banner adhering to the color scheme and lighting of this style reference"},
        {"type": "image", "data": base64.b64encode(style_bytes).decode("utf-8"), "mime_type": "image/png"},
    ],
    response_format={"type": "image", "aspect_ratio": "16:9", "image_size": "2K"},
)
```

### REST API (`curl`)
```bash
mkdir -p generations
cat > generations/flash_image_request.json << 'EOF'
{
  "model": "gemini-3.1-flash-image",
  "input": [
    {"type": "text", "text": "A sleek modern product advertisement for wireless headphones on a clean marble table, studio lighting"}
  ],
  "response_format": {
    "type": "image",
    "aspect_ratio": "16:9",
    "image_size": "2K"
  }
}
EOF

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @generations/flash_image_request.json > generations/flash_image_response.json
```

The response's `output_image.data` field holds the base64-encoded image bytes; decode and write them to the target file.

# Gemini 3.1 Flash Lite Image (`gemini-3.1-flash-lite-image`)

## Overview
Nano Banana 2 Lite is Google's fastest and cheapest Gemini image model — the draft tier for rapid concept exploration and quick visual iteration before promoting a picked result to a higher tier.

## Model Specification
- **Model ID**: `gemini-3.1-flash-lite-image`
- **API**: Interactions API (`client.interactions.create`) — this model does not use the older `generate_content` method.
- **Primary Use**: Image drafts, rapid prototyping, thumbnail concepts.
- **Cost**: Billable per call. Quote the current price from the live [pricing page](https://ai.google.dev/gemini-api/docs/pricing) and get explicit user approval before every generation — see the skill's cost-approval rule.
- **Reference images**: Up to 14 supported as additional `image` input parts.
- **Reproducibility**: No `seed` parameter is documented for this model. Treat every generation as non-deterministic; for "same image but change X" requests, reuse the exact original prompt and reference images rather than promising an identical re-roll.

## Request Shape

### Python SDK (`google-genai`, Interactions API)
```python
from google import genai
import base64

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.1-flash-lite-image",
    input="A futuristic city skyline at sunset, cyberpunk aesthetic, high detail",
    response_format={
        "type": "image",
        "aspect_ratio": "16:9",
        "image_size": "1K",
    },
)

with open("generations/output.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))
```

### Reference Image Input
Pass reference images as additional `input` parts (base64-encoded), alongside the text prompt:
```python
from google import genai
import base64

client = genai.Client()

with open("generations/refs/brand/logo.png", "rb") as f:
    logo_bytes = f.read()

interaction = client.interactions.create(
    model="gemini-3.1-flash-lite-image",
    input=[
        {"type": "text", "text": "Incorporate this logo style into a draft banner for summer sale"},
        {"type": "image", "data": base64.b64encode(logo_bytes).decode("utf-8"), "mime_type": "image/png"},
    ],
    response_format={"type": "image", "aspect_ratio": "16:9"},
)
```

### REST API (`curl`)
```bash
mkdir -p generations
cat > generations/lite_image_request.json << 'EOF'
{
  "model": "gemini-3.1-flash-lite-image",
  "input": [
    {"type": "text", "text": "A futuristic city skyline at sunset, cyberpunk aesthetic, high detail"}
  ],
  "response_format": {
    "type": "image",
    "aspect_ratio": "16:9",
    "image_size": "1K"
  }
}
EOF

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @generations/lite_image_request.json > generations/lite_image_response.json
```

The response's `output_image.data` field holds the base64-encoded image bytes; decode and write them to the target file.

# Gemini Omni Flash Video (`gemini-omni-flash-preview`)

## Overview
Gemini Omni Flash generates and edits video. It supports text-to-video, image-to-video, subject-reference video, stateful multi-turn video editing, and editing a user's own uploaded video. **Every paid run requires explicit user cost approval before execution — see the skill's cost-approval rule.**

## Model Specification
- **Model ID**: `gemini-omni-flash-preview`
- **API**: Interactions API (`client.interactions.create`) — this model does not use the older `generate_videos` or `:predictLongRunning` methods.
- **Primary Use**: Text-to-video, image-to-video, subject-reference video, video editing.
- **Cost**: Billable per call, priced per output. Quote the current price from the live [pricing page](https://ai.google.dev/gemini-api/docs/pricing) and get explicit user approval before submitting — one approval covers exactly one run.
- **Aspect ratios**: `16:9`, `9:16` documented for aspect-ratio-controlled requests.
- **Reproducibility**: No `seed` parameter is documented for this model. Treat every generation as non-deterministic.

## Request Shape

### Text-to-Video (Python SDK, Interactions API)
```python
import base64
from google import genai

client = genai.Client()

# Quote cost and wait for explicit user approval before running!
interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input="A marble rolling fast on a chain reaction style track, continuous smooth shot.",
)
with open("generations/marble.mp4", "wb") as f:
    f.write(base64.b64decode(interaction.output_video.data))
```

### Control Aspect Ratio
```python
interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input="A futuristic city with neon lights and flying cars, cyberpunk style",
    response_format={
        "type": "video",  # optional
        "aspect_ratio": "9:16",  # supported: "9:16", "16:9"
    },
)
```

### Image-to-Video
Pass a reference image and instructions as separate `input` parts:
```python
import base64
from google import genai

client = genai.Client()

with open("generations/refs/start_frame.png", "rb") as f:
    frame_bytes = f.read()

interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input=[
        {"type": "image", "data": base64.b64encode(frame_bytes).decode("utf-8"), "mime_type": "image/png"},
        {"type": "text", "text": "The scene animates smoothly as the character steps forward into the misty forest."},
    ],
)
with open("generations/forest.mp4", "wb") as f:
    f.write(base64.b64decode(interaction.output_video.data))
```

### Subject Reference (multiple reference images)
```python
interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input=[
        {"type": "image", "data": cat_b64, "mime_type": "image/png"},
        {"type": "image", "data": yarn_b64, "mime_type": "image/png"},
        {"type": "text", "text": "A cat playfully batting at a ball of yarn."},
    ],
)
```

### Stateful Multi-Turn Video Editing
Chain an edit onto a prior generation with `previous_interaction_id` — this is the closest thing this model offers to controlled reruns, not a seed:
```python
# Turn 1: generate
res1 = client.interactions.create(model="gemini-omni-flash-preview", input="A woman playing violin outdoors.")

# Turn 2: edit the previous result
res2 = client.interactions.create(
    model="gemini-omni-flash-preview",
    previous_interaction_id=res1.id,
    input="Make the violin invisible.",
)
with open("generations/violin.mp4", "wb") as f:
    f.write(base64.b64decode(res2.output_video.data))
```

### Editing a User's Own Uploaded Video
```python
import time
from google import genai

client = genai.Client()

video_file = client.files.upload(file="Video.mp4")
while video_file.state == "PROCESSING":
    time.sleep(10)
    video_file = client.files.get(name=video_file.name)
if video_file.state == "FAILED":
    raise ValueError(video_file.state)

interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "text", "text": "When the person touches the mirror, make the mirror ripple beautifully like liquid, and the person's arm turns into reflective mirror material"},
    ],
)
with open("generations/mirror.mp4", "wb") as f:
    f.write(base64.b64decode(interaction.output_video.data))
```

### Large Outputs: Retrieve via URI Instead of Inline Base64
For outputs too large for inline base64, request `delivery: "uri"` and poll the Files API until `ACTIVE`:
```python
import time
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-omni-flash-preview",
    input="A beautiful sunset over a calm ocean.",
    response_format={"type": "video", "delivery": "uri"},
)

video_output = interaction.output_video
file_name = video_output.uri.split("/")[-1]

while True:
    f_info = client.files.get(name=f"files/{file_name}")
    if f_info.state.name == "ACTIVE":
        break
    if f_info.state.name == "FAILED":
        raise RuntimeError("Generation failed.")
    time.sleep(5)

video_bytes = client.files.download(file=video_output.uri)
with open("generations/output.mp4", "wb") as f:
    f.write(video_bytes)
```

### REST API (`curl`)
```bash
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
     "model": "gemini-omni-flash-preview",
     "input": "A marble rolling fast on a chain reaction style track, continuous smooth shot."
    }'
```

The response's `output_video.data` field holds base64-encoded video bytes (or `output_video.uri` when `delivery: "uri"` was requested); decode/download and write to the target file. The response envelope also includes an `id` field — log it so multi-turn edits can chain via `previous_interaction_id`.