> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apipod.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Nano Banana 2.1

> Nano Banana 2.1 is Google's next-generation Nano Banana 2 image model, built on Gemini 3.6 Flash, with improved realism, visual design, text rendering and multi-turn character consistency.



## OpenAPI

````yaml api-reference/openapi/nano-banana--nano-banana-2.1.yaml POST /v1/images/generations
openapi: 3.1.0
info:
  title: Nano Banana 2.1 API
  version: 1.0.0
  description: >-
    Nano Banana 2.1 is Google's next-generation Nano Banana 2 image generation
    and editing model, built on Gemini 3.6 Flash, with improved realism, visual
    design, text rendering and character consistency across editing turns. In
    APIPod, the public model ID is nano-banana-2.1. It generates and edits
    images at 1K, 2K or 4K (the 512px tier is not supported), accepts text and
    up to 14 image inputs, and returns results through asynchronous image tasks.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/images/generations:
    post:
      tags:
        - Nano Banana 2.1
      summary: Create Generation Task
      description: >-
        Nano Banana 2.1 is Google's next-generation Nano Banana 2 image
        generation and editing model, built on Gemini 3.6 Flash, with improved
        realism, visual design, text rendering and character consistency across
        editing turns. In APIPod, the public model ID is nano-banana-2.1. It
        generates and edits images at 1K, 2K or 4K (the 512px tier is not
        supported), accepts text and up to 14 image inputs, and returns results
        through asynchronous image tasks.
      operationId: create-nano-banana-nano-banana-2.1
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Nano Banana 2.1
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: nano-banana-2.1
                prompt:
                  type: string
                  title: Prompt
                  description: Describe the content of the image to be generated.
                  maxLength: 3993
                image_urls:
                  type: array
                  title: Input Images
                  items:
                    type: string
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: the generated image's width and height aspect ratio.
                  enum:
                    - '1:1'
                    - '1:4'
                    - '1:8'
                    - '2:3'
                    - '3:2'
                    - '3:4'
                    - '4:1'
                    - '4:3'
                    - '4:5'
                    - '5:4'
                    - '8:1'
                    - '9:16'
                    - '16:9'
                    - '21:9'
                  default: '1:1'
                quality:
                  type: string
                  title: Quality
                  description: Output image resolution.
                  enum:
                    - 1K
                    - 2K
                    - 4K
                  default: 1K
              required:
                - model
                - prompt
            example:
              model: nano-banana-2.1
              prompt: >-
                A premium product photograph on a dark studio set, precise
                typography, soft rim lighting, highly detailed.
              aspect_ratio: '1:1'
              quality: 1K
      responses:
        '200':
          description: Task accepted
          content:
            application/json:
              schema:
                type: object
                title: Task Submit Response
                description: Standard response for task submission
                properties:
                  code:
                    type: integer
                  data:
                    type: object
                    title: Task Submit Data
                    description: Data content for task submission
                    properties:
                      task_id:
                        type: string
                        description: generatation task id
                  message:
                    type: string
                required:
                  - code
                  - message
                  - data
              example:
                code: 200
                message: success
                data:
                  task_id: img_task_01JEXAMPLE
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: |-
            curl https://api.apipod.ai/v1/images/generations \
              -H "Authorization: Bearer $APIPOD_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
              "model": "nano-banana-2.1",
              "prompt": "A premium product photograph on a dark studio set, precise typography, soft rim lighting, highly detailed.",
              "aspect_ratio": "1:1",
              "quality": "1K"
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "nano-banana-2.1",
              "prompt": "A premium product photograph on a dark studio set, precise typography, soft rim lighting, highly detailed.",
              "aspect_ratio": "1:1",
              "quality": "1K"
            }

            response = requests.post(
                "https://api.apipod.ai/v1/images/generations",
                headers={
                    "Authorization": f"Bearer {os.environ['APIPOD_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json=payload,
                timeout=60,
            )
            response.raise_for_status()
            print(response.json())
        - lang: Go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "encoding/json"
                "fmt"
                "net/http"
                "os"
            )

            func main() {
                payload := map[string]any{}
                if err := json.Unmarshal([]byte(`{
              "model": "nano-banana-2.1",
              "prompt": "A premium product photograph on a dark studio set, precise typography, soft rim lighting, highly detailed.",
              "aspect_ratio": "1:1",
              "quality": "1K"
            }`), &payload); err != nil {
                    panic(err)
                }
                body, err := json.Marshal(payload)
                if err != nil {
                    panic(err)
                }

                req, err := http.NewRequest(http.MethodPost, "https://api.apipod.ai/v1/images/generations", bytes.NewReader(body))
                if err != nil {
                    panic(err)
                }
                req.Header.Set("Authorization", "Bearer "+os.Getenv("APIPOD_API_KEY"))
                req.Header.Set("Content-Type", "application/json")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()
                fmt.Println(resp.Status)
            }
        - lang: Rust
          label: Rust
          source: |-
            use reqwest::Client;
            use serde_json::json;
            use std::env;

            #[tokio::main]
            async fn main() -> Result<(), Box<dyn std::error::Error>> {
                let payload = json!({
              "model": "nano-banana-2.1",
              "prompt": "A premium product photograph on a dark studio set, precise typography, soft rim lighting, highly detailed.",
              "aspect_ratio": "1:1",
              "quality": "1K"
            });
                let response = Client::new()
                    .post("https://api.apipod.ai/v1/images/generations")
                    .bearer_auth(env::var("APIPOD_API_KEY")?)
                    .json(&payload)
                    .send()
                    .await?
                    .error_for_status()?;

                println!("{}", response.text().await?);
                Ok(())
            }
        - lang: JavaScript
          label: JavaScript
          source: >-
            const response = await
            fetch("https://api.apipod.ai/v1/images/generations", {
              method: "POST",
              headers: {
                Authorization: `Bearer ${process.env.APIPOD_API_KEY}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify(
              {
                "model": "nano-banana-2.1",
                "prompt": "A premium product photograph on a dark studio set, precise typography, soft rim lighting, highly detailed.",
                "aspect_ratio": "1:1",
                "quality": "1K"
              }
              ),
            });


            if (!response.ok) {
              throw new Error(`APIPod request failed: ${response.status} ${await response.text()}`);
            }


            console.log(await response.json());
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIPod API key
      description: Use your APIPod API key as a Bearer token in the Authorization header.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.