NanoBanana API Quickstart

Welcome to the NanoBanana API!

This quickstart guide will walk you through the essential steps to start generating and editing images using our AI models.

Overview

Generate Images

Create AI images from text descriptions or edit existing images

Task Details

Query task status and get generated image results

Authentication

All API requests require authentication via Bearer Token.

Get Your API Key

Visit the API Key Management Page to obtain your API key.

Add to Request Headers

Include your API key in all requests:

Authorization: Bearer YOUR_API_KEY

Keep your API key secure and never share it publicly. If compromised, reset it immediately in the management page.

Basic Usage

1. Generate an Image

Start by creating your first image generation task:

curl -X POST "https://api.nanobananaapi.ai/api/v1/nanobanana/generate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A beautiful sunset over mountains",
    "type": "TEXTTOIAMGE",
    "numImages": 1,
    "callBackUrl": "https://your-callback-url.com/webhook"
  }'

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();

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()

Response:

{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "task12345"
  }
}

2. Check Task Status

Use the returned taskId to monitor progress:

curl -X GET "https://api.nanobananaapi.ai/api/v1/nanobanana/record-info?taskId=task12345" \
  -H "Authorization: Bearer YOUR_API_KEY"

async function checkStatus(taskId) {
  try {
    const response = await fetch(`https://api.nanobananaapi.ai/api/v1/nanobanana/record-info?taskId=${taskId}`, {
      method: 'GET',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    });
    
    const result = await response.json();
    
    if (response.ok) {
      const taskData = result;
      
      switch (taskData.successFlag) {
        case 0:
          console.log('Task is generating...');
          break;
        case 1:
          console.log('Task completed successfully!');
          console.log('Result image:', taskData.response?.resultImageUrl);
          break;
        case 2:
          console.log('Create task failed');
          break;
        case 3:
          console.log('Generation failed');
          break;
      }
      return taskData;
    } else {
      console.error('Query failed');
      return null;
    }
  } catch (error) {
    console.error('Status check failed:', error.message);
    return null;
  }
}

checkStatus('task12345');

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')

Status Values:

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

Complete Example

Here’s a complete workflow example:

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();

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
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()

Parameters

Required Parameters

Parameter	Type	Description
`prompt`	string	Text description for image generation
`type`	string	Generation type: `TEXTTOIAMGE` or `IMAGETOIAMGE`
`callBackUrl`	string	Webhook callback URL

Optional Parameters

Parameter	Type	Description	Default
`numImages`	integer	Number of images to generate (1-4)	1
`imageUrls`	array	Input image URLs for editing	-
`watermark`	string	Watermark text for generated images	-

Next Steps

Generate Images

Learn about all generation parameters and advanced options

Check Account Credits

Monitor your account credit balance

Support

Need help? Contact our technical support:

Technical Support: support@nanobanana.com

Ready to create amazing AI images? Start with the examples above and explore the full API capabilities!

Getting started

NanoBanana API

Common API

Welcome to the NanoBanana API!

Overview

Generate Images

Task Details

Authentication

Basic Usage

1. Generate an Image

2. Check Task Status

Complete Example

Parameters

Required Parameters

Optional Parameters

Next Steps

Generate Images

Check Account Credits

Support

​Welcome to the NanoBanana API!

​Overview

Generate Images

Task Details

​Authentication

​Basic Usage

​1. Generate an Image

​2. Check Task Status

​Complete Example

​Parameters

​Required Parameters

​Optional Parameters

​Next Steps

Generate Images

Check Account Credits

​Support

Welcome to the NanoBanana API!

Overview

Authentication

Basic Usage

1. Generate an Image

2. Check Task Status

Complete Example

Parameters

Required Parameters

Optional Parameters

Next Steps

Support