NanoBanana API

https://docs.nanobananaapi.ai/
Admin
NanoBanana API is an AI-powered image generation and editing service that enables developers to...
Tokens:20,508
Snippets:137
Trust Score:7.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Generate an Image

Source: https://docs.nanobananaapi.ai/quickstart

Start by creating your first image generation task. This endpoint allows you to generate AI images from text descriptions.

```APIDOC
## POST /api/v1/nanobanana/generate

### Description
Creates an AI image generation task based on a text prompt.

### Method
POST

### Endpoint
https://api.nanobananaapi.ai/api/v1/nanobanana/generate

### Parameters
#### Request Body
- **prompt** (string) - Required - The text description for the image to be generated.
- **type** (string) - Required - The type of generation task, e.g., "TEXTTOIAMGE".
- **numImages** (integer) - Optional - The number of images to generate.
- **callBackUrl** (string) - Optional - A URL to receive webhook notifications about task completion.

### Request Example
```json
{
  "prompt": "A beautiful sunset over mountains",
  "type": "TEXTTOIAMGE",
  "numImages": 1,
  "callBackUrl": "https://your-callback-url.com/webhook"
}
```

### Response
#### Success Response (200)
- **code** (integer) - Indicates the success of the request.
- **msg** (string) - A message indicating the status of the request.
- **data** (object) - Contains data related to the task.
  - **taskId** (string) - The unique identifier for the generated task.

#### Response Example
```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "task12345"
  }
}
```
```

--------------------------------

### Success Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

This JSON structure is received when a Nanobanana Generate-2 image generation task completes successfully. It includes task details and the URL for the generated image.

```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "31ce2c17b257492959d62279e6d01a54",
    "paramJson": "{...}",
    "completeTime": "2026-02-27 24:00:00",
    "response": {
      "originImageUrl": null,
      "resultImageUrl": "https://tempfile.aiquickdraw.com/gemini-preview/xxxxxx.jpeg"
    },
    "successFlag": 1,
    "errorCode": null,
    "errorMessage": null,
    "operationType": "nano-banana-2_1k",
    "createTime": "2026-02-27 24:00:00"
  }
}
```

--------------------------------

### Receive NanoBanana Pro Callbacks in Python

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-pro-callbacks

Implement a Flask application to handle incoming POST requests for NanoBanana Pro callbacks. This example shows how to parse the callback data, log task status, download generated images upon success, and handle various error codes. It requires the flask and requests libraries.

```python
from flask import Flask, request, jsonify
import requests
import os

app = Flask(__name__)

@app.route('/nanobanana-pro-callback', methods=['POST'])
def handle_callback():
    data = request.json
    
    code = data.get('code')
    msg = data.get('msg')
    callback_data = data.get('data', {})
    task_id = callback_data.get('taskId')
    info = callback_data.get('info', {})
    result_image_url = info.get('resultImageUrl')
    
    print(f"Received NanoBanana Pro callback:")
    print(f"Task ID: {task_id}")
    print(f"Status: {code}, Message: {msg}")
    
    if code == 200:
        # Task completed successfully
        print("NanoBanana Pro task completed successfully")
        
        print(f"Generated image URL: {result_image_url}")
        
        # Download the generated image
        if result_image_url:
            try:
                result_filename = f"nanobananapro_result_{task_id}.jpg"
                download_file(result_image_url, result_filename)
                print(f"Generated image downloaded as {result_filename}")
            except Exception as e:
                print(f"Failed to download generated image: {e}")
                
    else:
        # Task failed
        print(f"NanoBanana Pro task failed: {msg}")
        
        # Handle specific error types
        if code == 400:
            print("Content policy violation - please adjust your prompt")
        elif code == 500:
            print("Internal error - please try again later")
        elif code == 501:
            print("Generation task failed - may need to adjust parameters")
    
    # Return 200 status code to confirm callback receipt
    return jsonify({'status': 'received'}), 200

def download_file(url, filename):
    """Download file from URL and save locally"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
    
    os.makedirs('downloads', exist_ok=True)
    filepath = os.path.join('downloads', filename)
    
    with open(filepath, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000)

```

--------------------------------

### Get Task Details

Source: https://docs.nanobananaapi.ai/nanobanana-api/get-task-details

Query NanoBanana task execution details and status. The status codes indicate the progress and outcome of the task.

```APIDOC
## GET /api/v1/nanobanana/record-info

### Description
Query NanoBanana task execution details and status.

### Status Descriptions
- 0: GENERATING - Task is currently being processed
- 1: SUCCESS - Task completed successfully
- 2: CREATE_TASK_FAILED - Failed to create the task
- 3: GENERATE_FAILED - Task creation succeeded but generation failed

### Method
GET

### Endpoint
/api/v1/nanobanana/record-info

### Parameters
#### Query Parameters
- **taskId** (string) - Required - Task ID (required)
  - example: nanobanana_123456

### Response
#### Success Response (200)
- **code** (integer) - Response status code (200, 400, 401, 404, 500)
- **msg** (string) - Response message
- **data** (object) - Response data
  - **taskId** (string) - Task ID
  - **paramJson** (string) - Request parameters in JSON format
  - **completeTime** (string) - Task completion time
  - **response** (object) - Generation result
    - **originImageUrl** (string) - BFL original image URL (valid for 10 minutes)
    - **resultImageUrl** (string) - Our server's image URL
  - **successFlag** (integer) - Generation status: 0-generating, 1-success, 2-create task failed, 3-generation failed
  - **errorCode** (integer) - Error code
  - **errorMessage** (string) - Error message
  - **createTime** (string) - Task creation time

#### Response Example
```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "nanobanana_task_123456",
    "paramJson": "",
    "completeTime": "",
    "response": {
      "originImageUrl": "https://bfl.com/image/original.jpg",
      "resultImageUrl": "https://ourserver.com/image/result.jpg"
    },
    "successFlag": 1,
    "errorCode": 0,
    "errorMessage": "",
    "createTime": ""
  }
}
```
```

--------------------------------

### Success Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

This JSON payload is received when an image generation task completes successfully. It includes a success message, status code 200, and the URL of the generated image.

```json
{
  "msg": "Image generated successfully.",
  "code": 200,
  "data": {
    "taskId": "9e4286b7b27960dfeb8e1d279b50b28d",
    "info": {
      "resultImageUrl": "https://tempfile.aiquickdraw.com/r/9e4286b7b27960dfeb8e1d279b50b28d_1756467493.jpg"
    }
  }
}
```

--------------------------------

### Generation Failed Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

This JSON payload indicates that the image generation task failed. It includes a status code of 501 and a failure message.

```json
{
  "code": 501,
  "msg": "Image generation task failed",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

--------------------------------

### Content Policy Violation Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

This JSON payload is sent when a prompt violates the content policy. It returns a status code of 400 and a message indicating the violation.

```json
{
  "code": 400,
  "msg": "Your prompt has been flagged for violating content policy",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

--------------------------------

### Sensitive Content Failure Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

This JSON structure is received when a Nanobanana Generate-2 image generation task fails due to sensitive content detection. It provides an error message and a specific error code.

```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "7dc1089163a9b00eaa4719b8862ddade",
    "paramJson": "{}",
    "completeTime": "2026-01-27 24:00:00",
    "response": null,
    "successFlag": 3,
    "errorCode": 422,
    "errorMessage": "The input or output was flagged as sensitive. Please try again with different inputs. (E005) (uIJ6l3ruRD)",
    "operationType": "nano-banana-2_1k",
    "createTime": "2026-02-27 24:00:00"
  }
}
```

--------------------------------

### Internal Error Callback Example

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

This JSON payload is received when an internal server error occurs during task processing. It returns a status code of 500 and an error message.

```json
{
  "code": 500,
  "msg": "Internal error, please try again later",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

--------------------------------

### Check Task Status with Python

Source: https://docs.nanobananaapi.ai/quickstart

This Python function checks the status of a task using its `task_id`. It makes a GET request to the API, parses the JSON response, and prints the status, including the result image URL if the task was successful. Requires the `requests` library.

```python
import requests

def check_status(task_id):
    url = f"https://api.nanobananaapi.ai/api/v1/nanobanana/record-info?taskId={task_id}"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    
    try:
        response = requests.get(url, headers=headers)
        result = response.json()
        
        if response.ok:
            success_flag = result.get('successFlag', 0)
            
            if success_flag == 0:
                print("Task is generating...")
            elif success_flag == 1:
                print("Task completed successfully!")
                result_url = result.get('response', {}).get('resultImageUrl', '')
                print(f"Result image: {result_url}")
            elif success_flag == 2:
                print("Create task failed")
            elif success_flag == 3:
                print("Generation failed")
            
            return result
        else:
            print("Query failed")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Status check failed: {e}")
        return None

check_status('task12345')
```

--------------------------------

### Node.js Callback Server for Generate-2

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

Set up an Express.js server to listen for callbacks from NanoBanana Generate-2. This snippet handles successful task completion, including downloading the generated image, and logs any errors.

```javascript
const express = require('express');
const fs = require('fs');
const https = require('https');
const app = express();

app.use(express.json());

app.post('/nanobanana-generate-2-callback', (req, res) => {
  const { code, msg, data } = req.body;
  const {
    taskId,
    successFlag,
    errorCode,
    errorMessage,
    response
  } = data || {};
  const resultImageUrl = response?.resultImageUrl || '';
  
  console.log('Received NanoBanana Generate-2 callback:', {
    taskId,
    httpCode: code,
    successFlag,
    errorCode,
    message: msg,
    errorMessage
  });
  
  if (successFlag === 1) {
    // Task completed successfully
    console.log('NanoBanana Generate-2 task completed successfully');
    console.log(`Generated image URL: ${resultImageUrl}`);
    
    // Download the generated image
    if (resultImageUrl) {
      downloadFile(resultImageUrl, `nanobanana_generate2_result_${taskId}.jpg`)
        .then(() => console.log('Generated image downloaded successfully'))
        .catch(err => console.error('Failed to download generated image:', err));
    }
  } else {
    // Task failed
    console.log('NanoBanana Generate-2 task failed:', errorMessage || msg || 'Unknown error');
    
    if (errorCode === 422) {
      console.log('Content/safety checks failed - please adjust your prompt or inputs');
    }
  }
  
  // Return 200 status code to confirm callback receipt
  res.status(200).json({ status: 'received' });
});

// Helper function: download file
function downloadFile(url, filename) {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(filename);
    
    https.get(url, (response) => {
      if (response.statusCode === 200) {
        response.pipe(file);
        file.on('finish', () => {
          file.close();
          resolve();
        });
      } else {
        reject(new Error(`HTTP ${response.statusCode}`));
      }
    }).on('error', reject);
  });
}

app.listen(3000, () => {
  console.log('NanoBanana Generate-2 callback server running on port 3000');
});

```

--------------------------------

### Receive NanoBanana Pro Callbacks in Node.js

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-pro-callbacks

Set up an Express.js server to listen for POST requests on a specific endpoint. This code handles successful task completions by downloading the generated image and logs errors for failed tasks. It requires the express, fs, and https modules.

```javascript
const express = require('express');
const fs = require('fs');
const https = require('https');
const app = express();

app.use(express.json());

app.post('/nanobanana-pro-callback', (req, res) => {
  const { code, msg, data } = req.body;
  
  console.log('Received NanoBanana Pro callback:', {
    taskId: data.taskId,
    status: code,
    message: msg
  });
  
  if (code === 200) {
    // Task completed successfully
    console.log('NanoBanana Pro task completed successfully');
    
    const { taskId, info } = data;
    const { resultImageUrl } = info;
    
    console.log(`Generated image URL: ${resultImageUrl}`);
    
    // Download the generated image
    if (resultImageUrl) {
      downloadFile(resultImageUrl, `nanobananapro_result_${taskId}.jpg`)
        .then(() => console.log('Generated image downloaded successfully'))
        .catch(err => console.error('Failed to download generated image:', err));
    }
    
  } else {
    // Task failed
    console.log('NanoBanana Pro task failed:', msg);
    
    // Handle specific error types
    if (code === 400) {
      console.log('Content policy violation - please adjust your prompt');
    } else if (code === 500) {
      console.log('Internal error - please try again later');
    } else if (code === 501) {
      console.log('Generation task failed - may need to adjust parameters');
    }
  }
  
  // Return 200 status code to confirm callback receipt
  res.status(200).json({ status: 'received' });
});

// Helper function: download file
function downloadFile(url, filename) {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(filename);
    
    https.get(url, (response) => {
      if (response.statusCode === 200) {
        response.pipe(file);
        file.on('finish', () => {
          file.close();
          resolve();
        });
      } else {
        reject(new Error(`HTTP ${response.statusCode}`));
      }
    }).on('error', reject);
  });
}

app.listen(3000, () => {
  console.log('NanoBanana Pro callback server running on port 3000');
});

```

--------------------------------

### Generate Image with NanoBananaAPI

Source: https://docs.nanobananaapi.ai/quickstart

Use this Python snippet to generate an image from a text prompt. Ensure you replace 'YOUR_API_KEY' with your actual API key. The code handles task initiation, waiting for completion, and retrieving the image URL or reporting errors.

```python
def main():
    api = NanoBananaAPI('YOUR_API_KEY')
    
    try:
        print('Starting image generation...')
        task_id = api.generate_image('A beautiful landscape painting')
        
        print(f'Task ID: {task_id}. Waiting for completion...')
        result = api.wait_for_completion(task_id)
        
        print('Image generated successfully!')
        print(f'Result Image URL: {result.get("resultImageUrl", "")}')
        
    except Exception as error:
        print(f'Error: {error}')

if __name__ == '__main__':
    main()
```

--------------------------------

### PHP Callback Reception for Image Generation

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

This PHP script processes callbacks from the NanoBanana API for image generation. It extracts task details, checks for success or failure, and downloads the generated image if successful. Ensure the 'downloads' directory exists or is created.

```php
<?php
header('Content-Type: application/json');

// Get POST data
$input = file_get_contents('php://input');
$data = json_decode($input, true);

$code = $data['code'] ?? null;
$msg = $data['msg'] ?? '';
$callbackData = $data['data'] ?? [];

$taskId = $callbackData['taskId'] ?? '';
$successFlag = $callbackData['successFlag'] ?? null;
$errorCode = $callbackData['errorCode'] ?? null;
$errorMessage = $callbackData['errorMessage'] ?? '';
$response = $callbackData['response'] ?? [];
$resultImageUrl = $response['resultImageUrl'] ?? '';

error_log("Received NanoBanana Generate-2 callback:");
error_log("Task ID: $taskId");
error_log("HTTP code: $code, successFlag: $successFlag, errorCode: $errorCode");
error_log("msg: $msg, errorMessage: $errorMessage");

if ($successFlag === 1) {
    // Task completed successfully
    error_log("NanoBanana Generate-2 task completed successfully");
    
    error_log("Generated image URL: $resultImageUrl");
    
    // Download the generated image
    if (!empty($resultImageUrl)) {
        try {
            $resultFilename = "nanobanana_generate2_result_{$taskId}.jpg";
            downloadFile($resultImageUrl, $resultFilename);
            error_log("Generated image downloaded as $resultFilename");
        } catch (Exception $e) {
            error_log("Failed to download generated image: " . $e->getMessage());
        }
    }
} else {
    // Task failed
    error_log("NanoBanana Generate-2 task failed: " . ($errorMessage ?: $msg));
    
    if ($errorCode === 422) {
        error_log("Content/safety checks failed - please adjust your prompt or inputs");
    }
}

// Return 200 status code to confirm callback receipt
http_response_code(200);
echo json_encode(['status' => 'received']);

function downloadFile($url, $filename) {
    $downloadDir = 'downloads';
    if (!is_dir($downloadDir)) {
        mkdir($downloadDir, 0755, true);
    }
    
    $filepath = $downloadDir . '/' . $filename;
    
    $fileContent = file_get_contents($url);
    if ($fileContent === false) {
        throw new Exception("Failed to download file from URL");
    }
    
    $result = file_put_contents($filepath, $fileContent);
    if ($result === false) {
        throw new Exception("Failed to save file locally");
    }
}
?>
```

--------------------------------

### Complete Image Generation Workflow in Python

Source: https://docs.nanobananaapi.ai/quickstart

This Python class facilitates image generation, task status checks, and completion waiting using the NanoBananaAPI. An API key is required.

```python
import requests
import time

class NanoBananaAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://api.nanobananaapi.ai/api/v1/nanobanana'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
      
    def generate_image(self, prompt, **options):
        data = {
            'prompt': prompt,
            'type': options.get('type', 'TEXTTOIAMGE'),
            'numImages': options.get('numImages', 1),
            'callBackUrl': options.get('callBackUrl'),
            'watermark': options.get('watermark')
        }
          
        if options.get('imageUrls'):
            data['imageUrls'] = options['imageUrls']
          
        response = requests.post(f'{self.base_url}/generate', 
                                 headers=self.headers, json=data)
        result = response.json()
          
        if not response.ok or result.get('code') != 200:
            raise Exception(f"Generation failed: {result.get('msg', 'Unknown error')}")
          
        return result['data']['taskId']
      
    def get_task_status(self, task_id):
        response = requests.get(f'{self.base_url}/record-info?taskId={task_id}',
                                headers={'Authorization': f'Bearer {self.api_key}'})
        return response.json()
      
    def wait_for_completion(self, task_id, max_wait_time=300):
        start_time = time.time()
          
        while time.time() - start_time < max_wait_time:
            status = self.get_task_status(task_id)
            success_flag = status.get('successFlag', 0)
              
            if success_flag == 0:
                print("Task is generating...")
            elif success_flag == 1:
                print("Generation completed successfully!")
                return status.get('response', {})
            elif success_flag in [2, 3]:
                error_msg = status.get('errorMessage', 'Generation failed')
                raise Exception(error_msg)
              
            time.sleep(3)
          
        raise Exception('Generation timeout')

  # Usage Example
```

--------------------------------

### Python Callback Server for Generate-2

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

Implement a Flask application to receive callbacks from NanoBanana Generate-2. This code processes the callback data, handles successful image generation by downloading the image, and logs any errors.

```python
from flask import Flask, request, jsonify
import requests
import os

app = Flask(__name__)

@app.route('/nanobanana-generate-2-callback', methods=['POST'])
def handle_callback():
    data = request.json
    
    code = data.get('code')
    msg = data.get('msg')
    callback_data = data.get('data', {})
    task_id = callback_data.get('taskId')
    success_flag = callback_data.get('successFlag')
    error_code = callback_data.get('errorCode')
    error_message = callback_data.get('errorMessage')
    response_data = callback_data.get('response') or {}
    result_image_url = response_data.get('resultImageUrl')
    
    print("Received NanoBanana Generate-2 callback:")
    print(f"Task ID: {task_id}")
    print(f"HTTP code: {code}, successFlag: {success_flag}, errorCode: {error_code}")
    print(f"msg: {msg}, errorMessage: {error_message}")
    
    if success_flag == 1:
        # Task completed successfully
        print("NanoBanana Generate-2 task completed successfully")
        print(f"Generated image URL: {result_image_url}")
        
        # Download the generated image
        if result_image_url:
            try:
                result_filename = f"nanobanana_generate2_result_{task_id}.jpg"
                download_file(result_image_url, result_filename)
                print(f"Generated image downloaded as {result_filename}")
            except Exception as e:
                print(f"Failed to download generated image: {e}")
    else:
        # Task failed
        print(f"NanoBanana Generate-2 task failed: {error_message or msg}")
        
        if error_code == 422:
            print("Content/safety checks failed - please adjust your prompt or inputs")
    
    # Return 200 status code to confirm callback receipt
    return jsonify({'status': 'received'}), 200

def download_file(url, filename):
    """Download file from URL and save locally"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
    
    os.makedirs('downloads', exist_ok=True)
    filepath = os.path.join('downloads', filename)
    
    with open(filepath, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

```

--------------------------------

### Node.js Image Generation Callback Server

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

Set up an Express.js server to listen for POST requests on the /nanobanana-image-callback endpoint. This code processes the callback data, logs the status, and initiates image download upon successful generation. It handles specific error codes for policy violations, internal errors, and generation failures.

```javascript
const express = require('express');
const fs = require('fs');
const https = require('https');
const app = express();

app.use(express.json());

app.post('/nanobanana-image-callback', (req, res) => {
  const { code, msg, data } = req.body;
  
  console.log('Received NanoBanana image generation callback:', {
    taskId: data.taskId,
    status: code,
    message: msg
  });
  
  if (code === 200) {
    // Task completed successfully
    console.log('NanoBanana image generation completed successfully');
    
    const { taskId, info } = data;
    const { resultImageUrl } = info;
    
    console.log(`Generated image URL: ${resultImageUrl}`);
    
    // Download the generated image
    if (resultImageUrl) {
      downloadFile(resultImageUrl, `nanobanana_result_${taskId}.jpg`)
        .then(() => console.log('Generated image downloaded successfully'))
        .catch(err => console.error('Failed to download generated image:', err));
    }
    
  } else {
    // Task failed
    console.log('NanoBanana image generation failed:', msg);
    
    // Handle specific error types
    if (code === 400) {
      console.log('Content policy violation - please adjust your prompt');
    } else if (code === 500) {
      console.log('Internal error - please try again later');
    } else if (code === 501) {
      console.log('Generation task failed - may need to adjust parameters');
    }
  }
  
  // Return 200 status code to confirm callback receipt
  res.status(200).json({ status: 'received' });
});

// Helper function: download file
function downloadFile(url, filename) {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(filename);
    
    https.get(url, (response) => {
      if (response.statusCode === 200) {
        response.pipe(file);
        file.on('finish', () => {
          file.close();
          resolve();
        });
      } else {
        reject(new Error(`HTTP ${response.statusCode}`));
      }
    }).on('error', reject);
  });
}

app.listen(3000, () => {
  console.log('Callback server running on port 3000');
});

```

--------------------------------

### Complete Image Generation Workflow in JavaScript

Source: https://docs.nanobananaapi.ai/quickstart

Use this JavaScript class to generate images, track their status, and wait for completion. Requires an API key for authentication.

```javascript
class NanoBananaAPI {
    constructor(apiKey) {
      this.apiKey = apiKey;
      this.baseUrl = 'https://api.nanobananaapi.ai/api/v1/nanobanana';
    }
    
    async generateImage(prompt, options = {}) {
      const response = await fetch(`${this.baseUrl}/generate`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          prompt,
          type: options.type || 'TEXTTOIAMGE',
          numImages: options.numImages || 1,
          callBackUrl: options.callBackUrl,
          watermark: options.watermark,
          imageUrls: options.imageUrls
        })
      });
      
      const result = await response.json();
      if (!response.ok || result.code !== 200) {
        throw new Error(`Generation failed: ${result.msg || 'Unknown error'}`);
      }
      
      return result.data.taskId;
    }
    
    async getTaskStatus(taskId) {
      const response = await fetch(`${this.baseUrl}/record-info?taskId=${taskId}`, {
        method: 'GET',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`
        }
      });
      
      const result = await response.json();
      return result;
    }
    
    async waitForCompletion(taskId, maxWaitTime = 300000) {
      const startTime = Date.now();
      
      while (Date.now() - startTime < maxWaitTime) {
        const status = await this.getTaskStatus(taskId);
        
        switch (status.successFlag) {
          case 0:
            console.log('Task is generating...');
            break;
          case 1:
            console.log('Generation completed successfully!');
            return status.response;
          case 2:
          case 3:
            throw new Error(status.errorMessage || 'Generation failed');
        }
        
        await new Promise(resolve => setTimeout(resolve, 3000));
      }
      
      throw new Error('Generation timeout');
    }
  }

  // Usage Example
  async function main() {
    const api = new NanoBananaAPI('YOUR_API_KEY');
    
    try {
      console.log('Starting image generation...');
      const taskId = await api.generateImage('A beautiful landscape painting');
      
      console.log(`Task ID: ${taskId}. Waiting for completion...`);
      const result = await api.waitForCompletion(taskId);
      
      console.log('Image generated successfully!');
      console.log('Result Image URL:', result.resultImageUrl);
      
    } catch (error) {
      console.error('Error:', error.message);
    }
  }

  main();
```

--------------------------------

### PHP Callback Reception and Image Download

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-pro-callbacks

This PHP script processes callbacks from NanoBanana Pro. It parses the JSON payload, logs task status and messages, and downloads the generated image upon successful completion. It also includes basic error handling for common status codes.

```php
<?php
header('Content-Type: application/json');

// Get POST data
$input = file_get_contents('php://input');
$data = json_decode($input, true);

$code = $data['code'] ?? null;
$msg = $data['msg'] ?? '';
$callbackData = $data['data'] ?? [];

$taskId = $callbackData['taskId'] ?? '';
$info = $callbackData['info'] ?? [];
$resultImageUrl = $info['resultImageUrl'] ?? '';

error_log("Received NanoBanana Pro callback:");
error_log("Task ID: $taskId");
error_log("Status: $code, Message: $msg");

if ($code === 200) {
    // Task completed successfully
    error_log("NanoBanana Pro task completed successfully");
    
    error_log("Generated image URL: $resultImageUrl");
    
    // Download the generated image
    if (!empty($resultImageUrl)) {
        try {
            $resultFilename = "nanobananapro_result_{$taskId}.jpg";
            downloadFile($resultImageUrl, $resultFilename);
            error_log("Generated image downloaded as $resultFilename");
        } catch (Exception $e) {
            error_log("Failed to download generated image: " . $e->getMessage());
        }
    }
    
} else {
    // Task failed
    error_log("NanoBanana Pro task failed: $msg");
    
    // Handle specific error types
    if ($code === 400) {
        error_log("Content policy violation - please adjust your prompt");
    } elseif ($code === 500) {
        error_log("Internal error - please try again later");
    } elseif ($code === 501) {
        error_log("Generation task failed - may need to adjust parameters");
    }
}

// Return 200 status code to confirm callback receipt
http_response_code(200);
echo json_encode(['status' => 'received']);

function downloadFile($url, $filename) {
    $downloadDir = 'downloads';
    if (!is_dir($downloadDir)) {
        mkdir($downloadDir, 0755, true);
    }
    
    $filepath = $downloadDir . '/' . $filename;
    
    $fileContent = file_get_contents($url);
    if ($fileContent === false) {
        throw new Exception("Failed to download file from URL");
    }
    
    $result = file_put_contents($filepath, $fileContent);
    if ($result === false) {
        throw new Exception("Failed to save file locally");
    }
}
?>
```

--------------------------------

### PHP Callback Reception and Image Download

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

This PHP script receives image generation callbacks, logs task details, and downloads the generated image if the task was successful. It handles different error codes and confirms receipt by returning a 200 status.

```php
<?php
header('Content-Type: application/json');

// Get POST data
$input = file_get_contents('php://input');
$data = json_decode($input, true);

$code = $data['code'] ?? null;
$msg = $data['msg'] ?? '';
$callbackData = $data['data'] ?? [];
$taskId = $callbackData['taskId'] ?? '';
$info = $callbackData['info'] ?? [];
$resultImageUrl = $info['resultImageUrl'] ?? '';

error_log("Received NanoBanana image generation callback:");
error_log("Task ID: $taskId");
error_log("Status: $code, Message: $msg");

if ($code === 200) {
    // Task completed successfully
    error_log("NanoBanana image generation completed successfully");
    
    error_log("Generated image URL: $resultImageUrl");
    
    // Download the generated image
    if (!empty($resultImageUrl)) {
        try {
            $resultFilename = "nanobanana_result_{$taskId}.jpg";
            downloadFile($resultImageUrl, $resultFilename);
            error_log("Generated image downloaded as $resultFilename");
        } catch (Exception $e) {
            error_log("Failed to download generated image: " . $e->getMessage());
        }
    }
    
} else {
    // Task failed
    error_log("NanoBanana image generation failed: $msg");
    
    // Handle specific error types
    if ($code === 400) {
        error_log("Content policy violation - please adjust your prompt");
    } elseif ($code === 500) {
        error_log("Internal error - please try again later");
    } elseif ($code === 501) {
        error_log("Generation task failed - may need to adjust parameters");
    }
}

// Return 200 status code to confirm callback receipt
http_response_code(200);
echo json_encode(['status' => 'received']);

function downloadFile($url, $filename) {
    $downloadDir = 'downloads';
    if (!is_dir($downloadDir)) {
        mkdir($downloadDir, 0755, true);
    }
    
    $filepath = $downloadDir . '/' . $filename;
    
    $fileContent = file_get_contents($url);
    if ($fileContent === false) {
        throw new Exception("Failed to download file from URL");
    }
    
    $result = file_put_contents($filepath, $fileContent);
    if ($result === false) {
        throw new Exception("Failed to save file locally");
    }
}
?>
```

--------------------------------

### Callback Request Format

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

The system sends a POST request to your `callBackUrl` with a JSON payload containing the task status and results.

```APIDOC
## Callback Request Format

The system will send a POST request to your `callBackUrl` in the following format:

### Success Callback
```json
{
  "msg": "Image generated successfully.",
  "code": 200,
  "data": {
    "taskId": "9e4286b7b27960dfeb8e1d279b50b28d",
    "info": {
      "resultImageUrl": "https://tempfile.aiquickdraw.com/r/9e4286b7b27960dfeb8e1d279b50b28d_1756467493.jpg"
    }
  }
}
```

### Content Policy Violation Callback
```json
{
  "code": 400,
  "msg": "Your prompt has been flagged for violating content policy",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

### Generation Failed Callback
```json
{
  "code": 501,
  "msg": "Image generation task failed",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

### Internal Error Callback
```json
{
  "code": 500,
  "msg": "Internal error, please try again later",
  "data": {
    "taskId": "task12345",
    "info": {
      "resultImageUrl": ""
    }
  }
}
```

## Status Code Description

- **code** (integer, required): Callback status code indicating task processing result.
  - 200: Success - Image generation successful
  - 400: Failed - Your prompt was flagged for violating content policy
  - 500: Failed - Internal error, please try again later
  - 501: Failed - Image generation task failed
- **msg** (string, required): Status message providing detailed status description.
- **data.taskId** (string, required): Task ID, consistent with the taskId returned when you submitted the task.
- **data.info.resultImageUrl** (string): Generated image URL on our server. Only exists on success.
```

--------------------------------

### Python Flask Image Generation Callback Server

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-or-edit-image-callbacks

Implement a Flask application to handle image generation callbacks. This Python code defines a route for receiving POST requests, parses the JSON payload, and logs the task status. It includes logic to download the generated image upon success and provides specific error handling for common issues.

```python
from flask import Flask, request, jsonify
import requests
import os

app = Flask(__name__)

@app.route('/nanobanana-image-callback', methods=['POST'])
def handle_callback():
    data = request.json
    
    code = data.get('code')
    msg = data.get('msg')
    callback_data = data.get('data', {})
    task_id = callback_data.get('taskId')
    info = callback_data.get('info', {})
    result_image_url = info.get('resultImageUrl')
    
    print(f"Received NanoBanana image generation callback:")
    print(f"Task ID: {task_id}")
    print(f"Status: {code}, Message: {msg}")
    
    if code == 200:
        # Task completed successfully
        print("NanoBanana image generation completed successfully")
        
        print(f"Generated image URL: {result_image_url}")
        
        # Download the generated image
        if result_image_url:
            try:
                result_filename = f"nanobanana_result_{task_id}.jpg"
                download_file(result_image_url, result_filename)
                print(f"Generated image downloaded as {result_filename}")
            except Exception as e:
                print(f"Failed to download generated image: {e}")
                
    else:
        # Task failed
        print(f"NanoBanana image generation failed: {msg}")
        
        # Handle specific error types
        if code == 400:
            print("Content policy violation - please adjust your prompt")
        elif code == 500:
            print("Internal error - please try again later")
        elif code == 501:
            print("Generation task failed - may need to adjust parameters")
    
    # Return 200 status code to confirm callback receipt
    return jsonify({'status': 'received'}), 200

def download_file(url, filename):
    """Download file from URL and save locally"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
    
    os.makedirs('downloads', exist_ok=True)
    filepath = os.path.join('downloads', filename)
    
    with open(filepath, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

if __name__ == '__main__':

```

--------------------------------

### Generate Image with Python

Source: https://docs.nanobananaapi.ai/quickstart

Submit an image generation task using Python's requests library. The function prints the task submission status and returns the taskId on success. Handle potential request exceptions.

```python
import requests

def generate_image():
    url = "https://api.nanobananaapi.ai/api/v1/nanobanana/generate"
    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }
    data = {
        "prompt": "A beautiful sunset over mountains",
        "type": "TEXTTOIAMGE",
        "numImages": 1,
        "callBackUrl": "https://your-callback-url.com/webhook"
    }
    
    try:
        response = requests.post(url, headers=headers, json=data)
        result = response.json()
        
        if response.ok and result.get('code') == 200:
            print(f"Task submitted: {result}")
            print(f"Task ID: {result['data']['taskId']}")
            return result['data']['taskId']
        else:
            print(f"Request failed: {result.get('msg', 'Unknown error')}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

generate_image()
```

--------------------------------

### Generate Image with Node.js

Source: https://docs.nanobananaapi.ai/quickstart

Use Node.js with the fetch API to submit an image generation task. The function returns the taskId on success or null on failure. Ensure your API key and callback URL are correctly set.

```javascript
async function generateImage() {
  try {
    const response = await fetch('https://api.nanobananaapi.ai/api/v1/nanobanana/generate', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt: 'A beautiful sunset over mountains',
        type: 'TEXTTOIAMGE',
        numImages: 1,
        callBackUrl: 'https://your-callback-url.com/webhook'
      })
    });
    
    const result = await response.json();
    
    if (response.ok && result.code === 200) {
      console.log('Task submitted:', result);
      console.log('Task ID:', result.data.taskId);
      return result.data.taskId;
    } else {
      console.error('Request failed:', result.msg || 'Unknown error');
      return null;
    }
  } catch (error) {
    console.error('Error:', error.message);
    return null;
  }
}

generateImage();
```

--------------------------------

### Callback Request Format

Source: https://docs.nanobananaapi.ai/nanobanana-api/generate-image-2-callbacks

The system sends a POST request to your callBackUrl upon task completion. The request body contains details about the task's success or failure.

```APIDOC
## Callback Request Format

### Method
POST

### Content Type
application/json

### Request Body
This is the structure of the POST request sent to your `callBackUrl`.

#### Success Callback Example
```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "31ce2c17b257492959d62279e6d01a54",
    "paramJson": "{...}",
    "completeTime": "2026-02-27 24:00:00",
    "response": {
      "originImageUrl": null,
      "resultImageUrl": "https://tempfile.aiquickdraw.com/gemini-preview/xxxxxx.jpeg"
    },
    "successFlag": 1,
    "errorCode": null,
    "errorMessage": null,
    "operationType": "nano-banana-2_1k",
    "createTime": "2026-02-27 24:00:00"
  }
}
```

#### Sensitive Content Failure Callback Example
```json
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "7dc1089163a9b00eaa4719b8862ddade",
    "paramJson": "{}",
    "completeTime": "2026-01-27 24:00:00",
    "response": null,
    "successFlag": 3,
    "errorCode": 422,
    "errorMessage": "The input or output was flagged as sensitive. Please try again with different inputs. (E005) (uIJ6l3ruRD)",
    "operationType": "nano-banana-2_1k",
    "createTime": "2026-02-27 24:00:00"
  }
}
```
```
Tokens:
Raw