google/nano-banana-2/text-to-image-developer

टेक्स्ट-से-इमेज

DEV

Nano Banana 2 Text-to-Image Developer API by Google

google/nano-banana-2/text-to-image-developer

Text-to-image-developer

Google's lightweight yet powerful AI image generation model, built for creators who need fast, high-quality visuals from simple text prompts.

इनपुट

प्रॉम्प्ट *

पक्षानुपात

रिज़ॉल्यूशन

Thinking level

Enable web search

आउटपुट

निष्क्रिय

जेनरेट की गई छवियां यहां दिखाई देंगी

अपनी सेटिंग्स कॉन्फ़िगर करें और शुरू करने के लिए चलाएं पर क्लिक करें

आपके अनुरोध की लागत $0.04 प्रति रन होगी। $10 के साथ आप इस मॉडल को लगभग 250 बार चला सकते हैं।

आगे आप यह कर सकते हैं:

इमेज-से-वीडियो इमेज-से-इमेज

पैरामीटर

कोड उदाहरण
import requests
import time

# Step 1: Start image generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "google/nano-banana-2/text-to-image-developer",  # Required. model name
    "aspect_ratio": "example_value",  # The aspect ratio of the generated media
    "enable_base64_output": False,  # If enabled, the output will be encoded into a BASE64 string instead of a URL
    "enable_sync_mode": False,  # If set to true, the function will wait for the result to be generated and uploaded before returning the response
    "enable_web_search": False,  # If enabled, the model will use web search to ground the generation with real-time information
    "prompt": "A beautiful landscape with mountains and lake",  # Required. The positive prompt for the generation
    "resolution": "1k",  # The resolution of the output image. options: 1k | 2k | 4k
    "thinking_level": "default",  # Controls the amount of internal reasoning the model performs before generating a response. options: default | high | minimal
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] == "completed":
            print("Generated image:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

image_url = check_status()

इंस्टॉल करें

अपनी प्रोग्रामिंग भाषा के लिए आवश्यक पैकेज इंस्टॉल करें।

pip install requests

प्रमाणीकरण

सभी API अनुरोधों के लिए API कुंजी के माध्यम से प्रमाणीकरण आवश्यक है। आप अपनी API कुंजी Atlas Cloud डैशबोर्ड से प्राप्त कर सकते हैं।

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP हेडर

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

अपनी API कुंजी सुरक्षित रखें

क्लाइंट-साइड कोड या सार्वजनिक रिपॉज़िटरी में अपनी API कुंजी कभी उजागर न करें। इसके बजाय एनवायरनमेंट वेरिएबल या बैकएंड प्रॉक्सी का उपयोग करें।

अनुरोध सबमिट करें

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

अनुरोध सबमिट करें

एक असिंक्रोनस जनरेशन अनुरोध सबमिट करें। API एक प्रेडिक्शन ID लौटाता है जिसका उपयोग आप स्थिति जाँचने और परिणाम प्राप्त करने के लिए कर सकते हैं।

POST/api/v1/model/generateImage

अनुरोध बॉडी

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "google/nano-banana-2/text-to-image-developer",
    "prompt": "A beautiful landscape with mountains and lake"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

प्रतिक्रिया

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

स्थिति जाँचें

अपने अनुरोध की वर्तमान स्थिति जाँचने के लिए प्रेडिक्शन एंडपॉइंट को पोल करें।

GET/api/v1/model/prediction/{prediction_id}

पोलिंग उदाहरण

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

स्थिति मान

processingअनुरोध अभी भी प्रोसेस हो रहा है।

completedजनरेशन पूर्ण हो गया है। आउटपुट उपलब्ध हैं।

succeededजनरेशन सफल रहा। आउटपुट उपलब्ध हैं।

failedजनरेशन विफल हो गया। एरर फ़ील्ड जाँचें।

पूर्ण प्रतिक्रिया

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.png"
    ],
    "metrics": {
      "predict_time": 8.3
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

फ़ाइलें अपलोड करें

Atlas Cloud स्टोरेज पर फ़ाइलें अपलोड करें और एक URL प्राप्त करें जिसका उपयोग आप अपने API अनुरोधों में कर सकते हैं। अपलोड के लिए multipart/form-data का उपयोग करें।

POST/api/v1/model/uploadMedia

अपलोड उदाहरण

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

प्रतिक्रिया

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

Input Schema

अनुरोध बॉडी में निम्नलिखित पैरामीटर स्वीकार किए जाते हैं।

कुल: 8आवश्यक: 2वैकल्पिक: 6

modelstringrequired

model name

Default: "google/nano-banana-2/text-to-image-developer"

aspect_ratiostring

The aspect ratio of the generated media.

1:13:22:33:44:34:55:49:1616:921:9

enable_base64_outputboolean

If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.

Default: false

enable_sync_modeboolean

If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.

Default: false

enable_web_searchboolean

If enabled, the model will use web search to ground the generation with real-time information.

Default: false

promptstringrequired

The positive prompt for the generation.

resolutionstring

The resolution of the output image.

Default: "1k"

1k2k4k

thinking_levelstring

Controls the amount of internal reasoning the model performs before generating a response. Higher levels may improve quality on complex tasks but increase latency.

Default: "default"

defaulthighminimal

अनुरोध बॉडी का उदाहरण

{
  "model": "google/nano-banana-2/text-to-image-developer",
  "enable_base64_output": false,
  "enable_sync_mode": false,
  "enable_web_search": false,
  "prompt": "A beautiful landscape",
  "resolution": "1k",
  "thinking_level": "default"
}

Output Schema

API जनरेट किए गए आउटपुट URL के साथ एक प्रेडिक्शन प्रतिक्रिया लौटाता है।

created_atstring

ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

idstring

Unique identifier for the prediction, the ID of the prediction to get.

modelstring

Model ID used for the prediction.

outputsarray

Array of URLs to the generated content (empty when status is not completed).

statusstring

Status of the task: created, processing, completed, or failed.

प्रतिक्रिया का उदाहरण

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.png"
  ],
  "metrics": {
    "predict_time": 8.3
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills 400+ AI मॉडल को सीधे आपके AI कोडिंग असिस्टेंट में इंटीग्रेट करता है। इंस्टॉल करने के लिए एक कमांड, फिर इमेज, वीडियो जनरेट करने और LLM के साथ चैट करने के लिए प्राकृतिक भाषा का उपयोग करें।

समर्थित क्लाइंट

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ समर्थित क्लाइंट

इंस्टॉल करें

npx skills add AtlasCloudAI/atlas-cloud-skills

API कुंजी सेटअप करें

Atlas Cloud डैशबोर्ड से अपनी API कुंजी प्राप्त करें और इसे एनवायरनमेंट वेरिएबल के रूप में सेट करें।

export ATLASCLOUD_API_KEY="your-api-key-here"

क्षमताएँ

एक बार इंस्टॉल होने के बाद, आप सभी Atlas Cloud मॉडल तक पहुँचने के लिए अपने AI असिस्टेंट में प्राकृतिक भाषा का उपयोग कर सकते हैं।

इमेज जनरेशनNano Banana 2, Z-Image और अन्य मॉडल के साथ इमेज जनरेट करें।

वीडियो निर्माणKling, Vidu, Veo आदि के साथ टेक्स्ट या इमेज से वीडियो बनाएँ।

LLM चैटQwen, DeepSeek और अन्य बड़े भाषा मॉडल के साथ चैट करें।

मीडिया अपलोडइमेज एडिटिंग और इमेज-टू-वीडियो वर्कफ़्लो के लिए लोकल फ़ाइलें अपलोड करें।

और जानें

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server आपके IDE को Model Context Protocol के माध्यम से 400+ AI मॉडल से जोड़ता है। किसी भी MCP-संगत क्लाइंट के साथ काम करता है।

समर्थित क्लाइंट

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ समर्थित क्लाइंट

इंस्टॉल करें

npx -y atlascloud-mcp

कॉन्फ़िगरेशन

अपने IDE की MCP सेटिंग्स फ़ाइल में निम्नलिखित कॉन्फ़िगरेशन जोड़ें।

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

उपलब्ध टूल

atlas_generate_imageटेक्स्ट प्रॉम्प्ट से इमेज जनरेट करें।

atlas_generate_videoटेक्स्ट या इमेज से वीडियो बनाएँ।

atlas_chatबड़े भाषा मॉडल के साथ चैट करें।

atlas_list_models400+ उपलब्ध AI मॉडल ब्राउज़ करें।

atlas_quick_generateऑटो मॉडल चयन के साथ एक-चरण कंटेंट निर्माण।

atlas_upload_mediaAPI वर्कफ़्लो के लिए लोकल फ़ाइलें अपलोड करें।

और जानें

github.com/AtlasCloudAI/mcp-server

API स्कीमा

{
  "components": {
    "schemas": {
      "Input": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "google/nano-banana-2/text-to-image-developer"
          },
          "aspect_ratio": {
            "description": "The aspect ratio of the generated media.",
            "enum": [
              "1:1",
              "3:2",
              "2:3",
              "3:4",
              "4:3",
              "4:5",
              "5:4",
              "9:16",
              "16:9",
              "21:9"
            ],
            "type": "string",
            "x-placeholder": "Select aspect ratio"
          },
          "enable_base64_output": {
            "default": false,
            "description": "If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.",
            "disabled": true,
            "type": "boolean"
          },
          "enable_sync_mode": {
            "default": false,
            "description": "If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.",
            "disabled": true,
            "type": "boolean"
          },
          "enable_web_search": {
            "default": false,
            "description": "If enabled, the model will use web search to ground the generation with real-time information.",
            "type": "boolean"
          },
          "prompt": {
            "description": "The positive prompt for the generation.",
            "type": "string"
          },
          "resolution": {
            "default": "1k",
            "description": "The resolution of the output image.",
            "enum": [
              "1k",
              "2k",
              "4k"
            ],
            "type": "string"
          },
          "thinking_level": {
            "description": "Controls the amount of internal reasoning the model performs before generating a response. Higher levels may improve quality on complex tasks but increase latency.",
            "default": "default",
            "enum": [
              "default",
              "high",
              "minimal"
            ],
            "type": "string"
          }
        },
        "required": [
          "model",
          "prompt"
        ],
        "seed": {
          "title": "Seed",
          "type": "integer"
        },
        "type": "object",
        "x-order-properties": [
          "model",
          "prompt",
          "aspect_ratio",
          "resolution",
          "thinking_level",
          "enable_web_search",
          "enable_sync_mode",
          "enable_base64_output"
        ]
      },
      "PredictionResponse": {
        "properties": {
          "created_at": {
            "description": "ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).",
            "format": "date-time",
            "type": "string"
          },
          "has_nsfw_contents": {
            "description": "Array of boolean values indicating NSFW detection for each output.",
            "items": {
              "type": "boolean"
            },
            "type": "array"
          },
          "id": {
            "description": "Unique identifier for the prediction, the ID of the prediction to get.",
            "type": "string"
          },
          "model": {
            "description": "Model ID used for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array of URLs to the generated content (empty when status is not completed).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "status": {
            "description": "Status of the task: created, processing, completed, or failed.",
            "type": "string"
          },
          "urls": {
            "description": "Object containing related API endpoints.",
            "type": "object"
          }
        },
        "type": "object"
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  },
  "info": {
    "description": "The AtlasCloud API.",
    "title": "AtlasCloud API",
    "version": "1.0.0"
  },
  "openapi": "3.0.0",
  "paths": {
    "/api/v1/model/generateImage": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "required": true,
            "schema": {
              "description": "Request ID",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        }
      },
      "x-api-name": "model_result"
    }
  },
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ]
}

LLM के लिए प्रॉम्प्ट टेम्पलेट

# google/nano-banana-2/text-to-image-developer

> Google's lightweight yet powerful AI image generation model, built for creators who need fast, high-quality visuals from simple text prompts.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateImage` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `google/nano-banana-2/text-to-image-developer`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  model name
  - Default: `"google/nano-banana-2/text-to-image-developer"`

- **`prompt`** (`string`, _required_):
  The positive prompt for the generation.

- **`aspect_ratio`** (`string`, _optional_):
  The aspect ratio of the generated media.
  - Options: "1:1", "3:2", "2:3", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"

- **`resolution`** (`string`, _optional_):
  The resolution of the output image.
  - Default: `"1k"`
  - Options: "1k", "2k", "4k"

- **`thinking_level`** (`string`, _optional_):
  Controls the amount of internal reasoning the model performs before generating a response. Higher levels may improve quality on complex tasks but increase latency.
  - Default: `"default"`
  - Options: "default", "high", "minimal"

- **`enable_web_search`** (`boolean`, _optional_):
  If enabled, the model will use web search to ground the generation with real-time information.
  - Default: `false`

- **`enable_sync_mode`** (`boolean`, _optional_):
  If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API.
  - Default: `false`

- **`enable_base64_output`** (`boolean`, _optional_):
  If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API.
  - Default: `false`



**Required Parameters Example**:

```json
{
  "model": "google/nano-banana-2/text-to-image-developer",
  "prompt": ""
}
```


**Full Example**:

```json
{
  "model": "google/nano-banana-2/text-to-image-developer",
  "prompt": "",
  "aspect_ratio": "1:1",
  "resolution": "1k",
  "thinking_level": "default",
  "enable_web_search": false,
  "enable_sync_mode": false,
  "enable_base64_output": false
}
```


### Output Schema

The API returns the following output format:


- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

- **`has_nsfw_contents`** (`array[boolean]`, _optional_):
  Array of boolean values indicating NSFW detection for each output.

- **`id`** (`string`, _optional_):
  Unique identifier for the prediction, the ID of the prediction to get.

- **`model`** (`string`, _optional_):
  Model ID used for the prediction.

- **`outputs`** (`array[string]`, _optional_):
  Array of URLs to the generated content (empty when status is not completed).

- **`status`** (`string`, _optional_):
  Status of the task: created, processing, completed, or failed.

- **`urls`** (`object`, _optional_):
  Object containing related API endpoints.



**Example Response**:

```json
{
  "created_at": "",
  "has_nsfw_contents": [],
  "id": "",
  "model": "",
  "outputs": [
    ""
  ],
  "status": "",
  "urls": {}
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "google/nano-banana-2/text-to-image-developer",
  "prompt": "",
  "aspect_ratio": "1:1",
  "resolution": "1k",
  "thinking_level": "default",
  "enable_web_search": false,
  "enable_sync_mode": false,
  "enable_base64_output": false
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/google/nano-banana-2/text-to-image-developer)

cyberpunk detective standing on a rainy street at night, long coat, neon lights reflecting on wet pavement, holographic billboards above, dense futuristic buildings, smoke and fog in the air, moody cinematic lighting, dystopian atmosphere, blade runner style, ultra detailed

a lone traveler walking across an immense desert of towering sand dunes, endless golden dunes stretching to the horizon, powerful desert wind shaping the sand into massive waves, tiny human figure contrasted against colossal dunes, blazing sun casting long shadows across the desert, distant mountains barely visible through heat haze, fine sand drifting through the air, cinematic ultra wide shot, monumental scale landscape, dramatic natural lighting, ultra realistic, epic sci-fi atmosphere, dune style

a lone huntress standing on a high cliff overlooking a vast wild landscape, lush grasslands and forests stretching to the distant mountains, gigantic mechanical creatures roaming across the valley, ancient ruins of futuristic cities covered by vegetation, warm sunlight breaking through dramatic clouds, wind moving through tall grass, the huntress holding a bow and wearing tribal-tech armor, tiny human figure contrasted against the enormous environment and machines, cinematic ultra wide shot, epic scale landscape, vibrant natural colors mixed with advanced technology, ultra realistic, post-apocalyptic sci-fi world, horizon style

लोड हो रहा है...

Nano Banana 2 — Pro गुणवत्ता, Flash गति

Gemini 3.1 Flash Image के नाम से भी जाना जाता है

Google DeepMind का नवीनतम इमेज मॉडल, जो Nano Banana Pro की उन्नत क्षमताओं को Gemini Flash की गति के साथ जोड़ता है — 3-5 गुना तेज़ जनरेशन, 4K तक रिज़ॉल्यूशन, और एक ही वर्कफ़्लो में 5 कैरेक्टर तक की एकरूपता।

अगली पीढ़ी का इमेज जनरेशन

4K तक रिज़ॉल्यूशन आउटपुट (512px / 1K / 2K / 4K स्तर)
10+ आस्पेक्ट रेशियो, जिसमें 21:9, 1:4, 8:1 और अधिक शामिल
इमेज में सटीक और पठनीय टेक्स्ट रेंडरिंग
Flash गति पर लगभग Pro स्तर की गुणवत्ता (~95%)

स्मार्ट एडिटिंग और एकरूपता

विभिन्न दृश्यों में 5 कैरेक्टर तक की एकरूपता
एक वर्कफ़्लो में 14 ऑब्जेक्ट तक की फ़िडेलिटी
प्राकृतिक भाषा से लक्षित संपादन (हटाना, बदलना, पोज़ बदलना)
मल्टी-इमेज ब्लेंडिंग और निर्बाध कंपोज़िशन

Nano Banana 2 में नया क्या है

Pro से 3-5 गुना तेज़

Gemini 3.1 Flash आर्किटेक्चर पर निर्मित, Nano Banana 2 मानक इमेज 4-8 सेकंड में जनरेट करता है — जबकि Nano Banana Pro को 10-20 सेकंड लगते हैं।

इमेज सर्च ग्राउंडिंग

NB2 की सबसे खास विशेषता — जनरेशन के दौरान Google Search के माध्यम से वास्तविक दुनिया की रेफरेंस इमेज प्राप्त कर सकता है, जिससे लैंडमार्क, प्रसिद्ध व्यक्तियों और ब्रांड लोगो की सटीकता में उल्लेखनीय सुधार होता है।

सटीक टेक्स्ट रेंडरिंग

मार्केटिंग मॉकअप, ग्रीटिंग कार्ड और स्थानीयकृत सामग्री के लिए सटीक, पठनीय टेक्स्ट जनरेट करें। आप इमेज में टेक्स्ट का अनुवाद और स्थानीयकरण भी कर सकते हैं।

मल्टी-कैरेक्टर एकरूपता

विभिन्न दृश्यों में 5 कैरेक्टर और 14 ऑब्जेक्ट तक की दृश्य एकरूपता बनाए रखें — स्टोरीबोर्ड, कॉमिक्स और मार्केटिंग अभियानों के लिए उत्तम।

Text Rendering

Marketing Mockup with Text

Generate marketing visuals with accurate, legible text — one of NB2's standout improvements

Prompt

A minimalist coffee shop promotional poster with the text 'MORNING BREW — Fresh Roasted Daily' in elegant serif font, warm earth tones, steam rising from a ceramic cup, clean layout with plenty of whitespace

Character Consistency

Multi-Scene Character

Maintain character consistency across multiple scenes — supports up to 5 characters per workflow

Prompt

A young woman with short red hair and freckles, wearing a green jacket, standing in a rainy Tokyo street at night with neon reflections on wet pavement, cinematic lighting, photorealistic

Photo to Action Figure

Person to Action Figure

Transform people from photos into collectible action figures with custom packaging

Prompt

Transform the person in the photo into an action figure, styled after [CHARACTER_NAME] from [SOURCE / CONTEXT]. Next to the figure, display the accessories including [ITEM_1], [ITEM_2], and [ITEM_3]. On the top of the toy box, write "[BOX_LABEL_TOP]", and underneath it, "[BOX_LABEL_BOTTOM]". Place the box in a [BACKGROUND_SETTING] environment.

Search Grounding

Real-World Reference Generation

Leverage Image Search Grounding to generate accurate real-world subjects like landmarks and brands

Prompt

A photorealistic aerial view of the Eiffel Tower at golden hour, with the Seine River winding through Paris below, warm sunset light casting long shadows, high detail, 4K resolution

Product Photography

Product Design Render

Create professional product photography with precise control over lighting and composition

Prompt

A frosted glass perfume bottle with a marble cap on a white marble surface, soft studio lighting from the left, subtle reflections, minimalist luxury aesthetic, product photography style

Style Transfer

Artistic Style Transformation

Apply diverse artistic styles while maintaining subject integrity

Prompt

Transform this photo into Studio Ghibli animation style, keeping the same composition and subjects, lush watercolor backgrounds, soft diffused lighting, whimsical atmosphere

4K Output

Ultra High Resolution Scene

Generate detailed scenes at up to 4K resolution with rich textures

Prompt

A cozy Japanese ramen shop interior at night, steam rising from bowls, warm amber lighting, detailed wooden counter with various condiments, a chef working in the background, 4K, ultra detailed

उपयोग के मामले

🎬

स्टोरीबोर्डिंग और कॉमिक्स

📸

प्रोडक्ट फ़ोटोग्राफ़ी

📊

मार्केटिंग मॉकअप

📱

सोशल मीडिया कंटेंट

🔤

टेक्स्ट ओवरले डिज़ाइन

👤

कैरेक्टर डिज़ाइन

✨

फ़ोटो एडिटिंग और रीटचिंग

🎨

ब्रांड विज़ुअल कंटेंट

Nano Banana 2 क्यों चुनें?

⚡

Flash गति

Nano Banana Pro से 3-5 गुना तेज़, मानक जनरेशन समय मात्र 4-8 सेकंड

🎯

लगभग Pro स्तर की गुणवत्ता

अधिकांश परिदृश्यों में Pro की लगभग 95% इमेज गुणवत्ता प्राप्त करता है

💰

किफ़ायती

Nano Banana Pro की लगभग आधी कीमत — उच्च गुणवत्ता वाले AI इमेज जनरेशन को और अधिक सुलभ बनाता है

तकनीकी विनिर्देश

आर्किटेक्चर:Gemini 3.1 Flash (GEMPIX2)

रिज़ॉल्यूशन सपोर्ट:512px से 4K (512px / 1K / 2K / 4K स्तर)

आस्पेक्ट रेशियो:1:1, 4:3, 3:4, 2:3, 3:2, 16:9, 9:16, 1:4, 4:1, 8:1, 21:9

एकरूपता:प्रति वर्कफ़्लो 5 कैरेक्टर + 14 ऑब्जेक्ट तक

कंटेंट सुरक्षा:SynthID वॉटरमार्क, C2PA मानक संगत

API एक्सेस:Gemini API, Vertex AI, AI Studio, Gemini CLI

Nano Banana 2 का अनुभव करें

Flash गति पर Pro स्तर का इमेज जनरेशन — कैरेक्टर एकरूपता, टेक्स्ट रेंडरिंग और 4K रिज़ॉल्यूशन सपोर्ट के साथ शानदार विज़ुअल बनाएं।

✨शुरू करने के लिए मुफ़्त क्रेडिट

⚡तुरंत API एक्सेस

🌐कोई सेटअप आवश्यक नहीं

Google Nano Banana 2 Text-to-Image

Nano Banana 2 Text-to-Image (Gemini 3.1 Flash Image) is Google’s lightweight yet powerful AI image generation model, built for creators who need fast, high-quality visuals from simple text prompts. It transforms words into expressive, realistic images with remarkable clarity, composition, and style diversity — all within seconds.

Why Choose This?

Fast generation Optimized for speed while maintaining high visual quality.
Multi-resolution support Output in 1K, 2K, or 4K resolution based on your needs.
Flexible aspect ratios Multiple options including 1:1, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, and 21:9.
Cinematic quality Excels at photorealistic scenes with atmospheric lighting and anamorphic lens effects.
Prompt Enhancer Built-in tool to automatically improve your descriptions.
Format choice Export in PNG or JPEG format.

Parameters

Parameter	Required	Description
prompt	Yes	Text description of the desired image
aspect_ratio	No	Aspect ratio: 1:1, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
resolution	No	Output resolution: 1k (default), 2k, 4k
output_format	No	Output format: png (default), jpeg

How to Use

Write your prompt — describe the image in detail, including style, lighting, and composition.
Choose aspect ratio (optional) — select a preset or leave empty for default.
Select resolution — choose 1K, 2K, or 4K based on your needs.
Choose output format — PNG for transparency support, JPEG for smaller file size.
Use Prompt Enhancer (optional) — click to automatically refine your description.
Run — submit and download your generated image.

Pricing

Resolution	Cost
1k	$0.08
2k	$0.12
4k	$0.16

Best Use Cases

Cinematic Imagery — Generate atmospheric scenes with anamorphic lens effects and film-like quality.
Character Portraits — Create detailed character illustrations with specific attributes.
Social Media Content — Produce eye-catching visuals for various platforms with flexible aspect ratios.
Marketing & Ads — Generate professional images for campaigns and promotions.
Concept Art — Visualize creative ideas with photorealistic rendering.

Pro Tips

Use cinematic language like "anamorphic lens look," "neon signs reflected in puddles," or "rainy Tokyo street at night" for atmospheric results.
Be specific about character attributes (hair color, clothing, accessories) for consistent results.
Match aspect ratio to your target platform: 9:16 for Stories/Reels, 16:9 for banners, 1:1 for feeds.
Try the Prompt Enhancer to automatically improve your descriptions.
2K offers the best value — same price as 1K with higher resolution.

Notes

Prompt is the only required field.
If aspect_ratio is not selected, the model uses a default ratio.
4K resolution costs 2× the standard rate.
Ensure your prompts comply with Google's Safety Guidelines.

Nano Banana Pro Text-to-Image — Pro tier with enhanced quality.
Nano Banana Pro Edit — Edit images with text instructions.
Nano Banana 2 Edit — Image editing capabilities.

समान मॉडल देखें

NEW

इमेज-से-इमेज

DEV

Nano Banana 2 Lite Edit Developer

Google's fastest and most cost-efficient Nano Banana image model for editing, applying natural-language edits and multi-image composition to up to 14 reference images with low latency.

Nano Banana 2 Lite Text-to-Image Developer

Google's fastest and most cost-efficient Nano Banana image model, turning natural-language text prompts into high-quality 1k images in as little as 4 seconds for rapid, high-volume generation.

Nano Banana 2 Lite Edit

Nano banana lite is the efficiency-focused model in the image generation family. Sub-2 second latency with cost-effective generation and editing, fast multi-turn local edits, and 14 supported aspect ratios.

Nano Banana 2 Lite Text-to-image

Nano Banana 2 Reference to Image

Google's advanced AI-powered video-to-image generation model, designed to generate high-quality static images from video clips combined with text instructions.

Nano Banana 2 Reference to Image Developer

Google's advanced AI-powered video-to-image generation model, designed to generate high-quality static images from video clips combined with text instructions.

Nano Banana 2 Text-to-Image

Google's lightweight yet powerful AI image generation model, built for creators who need fast, high-quality visuals from simple text prompts.

Nano Banana 2 Edit Developer

Google's advanced AI-powered image editing and generation model, designed to make visual transformation as intuitive as describing it in words.

Nano Banana 2 Edit

Google's advanced AI-powered image editing and generation model, designed to make visual transformation as intuitive as describing it in words.

Nano Banana Pro Text-to-image Ultra

Nano Banana Pro is the next-generation Nano Banana image model, delivering sharper detail, richer color control, and faster diffusion for production-ready visuals.

Nano Banana Pro Edit Ultra

Nano Banana Pro Edit is an image editing tool built on the Nano Banana model family, designed for precise, AI-powered visual adjustments.

Nano Banana Pro Text-to-image

Nano Banana Pro is the next-generation Nano Banana image model, delivering sharper detail, richer color control, and faster diffusion for production-ready visuals.

From

$0.14/छवि