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

# NanoBanana API Quickstart

> Get started with the NanoBanana API in minutes. Learn how to generate and edit images using AI.

## 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

<CardGroup cols={2}>
  <Card title="Generate Images" icon="wand-magic-sparkles" href="/nanobanana-api/generate-or-edit-image">
    Create AI images from text descriptions or edit existing images
  </Card>

  <Card title="Task Details" icon="clock" href="/nanobanana-api/get-task-details">
    Query task status and get generated image results
  </Card>
</CardGroup>

## Authentication

All API requests require authentication via Bearer Token.

<Steps>
  <Step title="Get Your API Key">
    Visit the [API Key Management Page](https://nanobananaapi.ai/api-key) to obtain your API key.
  </Step>

  <Step title="Add to Request Headers">
    Include your API key in all requests:

    ```bash theme={null}
    Authorization: Bearer YOUR_API_KEY
    ```
  </Step>
</Steps>

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

## Basic Usage

### 1. Generate an Image

Start by creating your first image generation task:

<CodeGroup>
  ```bash cURL theme={null}
  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"
    }'
  ```

  ```javascript Node.js theme={null}
  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();
  ```

  ```python Python theme={null}
  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()
  ```
</CodeGroup>

**Response:**

```json theme={null}
{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "task12345"
  }
}
```

### 2. Check Task Status

Use the returned `taskId` to monitor progress:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://api.nanobananaapi.ai/api/v1/nanobanana/record-info?taskId=task12345" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript Node.js theme={null}
  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');
  ```

  ```python Python theme={null}
  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')
  ```
</CodeGroup>

**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:

<CodeGroup>
  ```javascript JavaScript theme={null}
  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();
  ```

  ```python Python theme={null}
  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()
  ```
</CodeGroup>

## 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

<CardGroup cols={2}>
  <Card title="Generate Images" icon="image" href="/nanobanana-api/generate-or-edit-image">
    Learn about all generation parameters and advanced options
  </Card>

  <Card title="Check Account Credits" icon="credit-card" href="/common-api/get-account-credits">
    Monitor your account credit balance
  </Card>
</CardGroup>

## Support

Need help? Contact our technical support:

* **Technical Support**: [support@nanobanana.com](mailto:support@nanobananaapi.ai)

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