Name: Nano-Banana-Pro – AI Image Generation | $0.2/call | API.market
Brand: magicapi
SKU: api-magicapi-image-generation-editing-google-nano-banana-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🍌 State-of-the-Art Image Generation & Editing API (Nano-Banana-Pro)

## Overview

The Nano-Banana-Pro API is a cutting-edge image generation and editing service powered by Google's advanced AI model. This API allows developers to effortlessly generate and modify high-quality images based on text prompts, reference images, and additional parameters. With state-of-the-art capabilities, Nano-Banana-Pro enables creative and dynamic visual content creation for various use cases.

## Features

- **High-Quality Image Generation**: Create stunning images based on detailed text descriptions.
- **Image Editing**: Transform or enhance your existing images with reference inputs.
- **Flexible Aspect Ratios**: Support for various aspect ratios, including 16:9, 4:3, and more.
- **Multiple Output Formats**: Generate images in your preferred format, such as JPG or PNG.
- **Safety Filters**: Configurable safety filters to ensure safe and appropriate content generation.
- **High Resolutions**: Generate images in multiple resolutions including 1K, 2K, and 4K.

## Use Cases

- **Marketing & Advertising**: Develop visually captivating ad creatives that align with your brand's message.
- **E-commerce**: Create high-quality product images to enhance your online store's visual presentation.
- **Social Media**: Generate engaging and shareable content for various social media platforms.
- **Entertainment**: Design imaginative graphics for games, animations, and digital media.
- **Art & Design**: Assist artists and designers in visualizing concepts and creating digital art.

## Visual Examples

### Example Input

**Prompt:** "Glossy candy-colored 3D letters in hot pink, electric orange, and lime green on a sun-drenched poolside patio with bold terrazzo tiles and vintage lounge chairs in turquoise and yellow. Shot on Kodachrome film with a Hasselblad 500C, warm golden afternoon sunlight, dramatic lens flare, punchy oversaturated colors with that distinctive 70s yellow-orange cast, shallow depth of field with the text sharp in the foreground, tropical palms and a sparkling aquamarine pool behind that spells out "Run Google Nano Banana [pro] on 'API.market!'" Make it grand and nice.   (API.market is the platform name, make it super huge)""  
**Resolution:** 2K  
**Aspect ratio:** 4:3  
**Output Format:** PNG  
**Safety Filter Level:** Block Only High

### Example Output

![Generated Image](https://blog.api.market/wp-content/uploads/2025/12/nano-banana-pro-api-market.png)

## Pricing

- **Pay As You Go (PAYG)**: Only pay for what you use.
- **1 API Unit = 1 Image Processed**
- GET requests to check prediction status are free and don't count toward API unit usage.
- No monthly subscription fees or usage limits – simple per-call pricing.

## API Documentation

### Base URL

All API requests should be made to: `https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro`

### Authentication

Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing

**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

1. Submit a prediction request to the POST endpoint.
2. Receive a prediction ID in the response.
3. Poll the GET endpoint with the prediction ID to check status.
4. Continue polling until the prediction is complete.

The processing time varies depending on the complexity of the request. Implement the following:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

### Endpoints

#### Create Prediction

Create a prediction using the google/nano-banana-pro model.

**Endpoint:** `POST /api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions`

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "How engineers see the San Francisco Bridge",
      "resolution": "2K",
      "aspect_ratio": "4:3",
      "output_format": "png",
      "safety_filter_level": "block_only_high"
    },
    "version": "81a5073adeced23b51ae9f85cd86c88954e7f25d7894eea0c7ebbc0c24d6831a"
  }'
```

**Response Example:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "81a5073adeced23b51ae9f85cd86c88954e7f25d7894eea0c7ebbc0c24d6831a",
  "status": "starting",
  "created_at": "2025-12-05T07:34:11.348Z"
}
```

#### Get Prediction Status

Check the status and results of a prediction.

**Endpoint:** `GET /api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions/{id}`

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response Example (Succeeded):**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/nano-banana-pro-api-market.png",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

### Status Codes

- **200 OK**: Request successful.
- **201 Created**: Resource successfully created.
- **400 Bad Request**: Invalid input parameters or malformed request.
- **401 Unauthorized**: Missing or invalid API key.
- **403 Forbidden**: Valid API key but insufficient permissions.
- **404 Not Found**: Resource not found.
- **429 Too Many Requests**: Rate limit exceeded.
- **500 Internal Server Error**: Server-side error.
- **503 Service Unavailable**: Service temporarily unavailable.

### Rate Limits

- The API enforces rate limits to ensure fair usage and prevent abuse.
- Exceeding the rate limit results in a 429 Too Many Requests status code.
- Use exponential backoff or other retry strategies to handle rate limits.

### Error Handling

When errors occur, the API returns a JSON response with an error message. Implement robust error handling for:

- **400 Bad Request**: Check input parameters.
- **401 Unauthorized**: Verify API key.
- **500 Internal Server Error**: Retry the request after a delay.
- **503 Service Unavailable**: Implement retry with exponential backoff.

**Error Response Example:**
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code

#### JavaScript Example

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ input: inputData, version: "81a5073adeced23b51ae9f85cd86c88954e7f25d7894eea0c7ebbc0c24d6831a" })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds
  const POLL_INTERVAL = 1000; // 1 second
  
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    
    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```

#### Python Example

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"input": input_data, "version": "81a5073adeced23b51ae9f85cd86c88954e7f25d7894eea0c7ebbc0c24d6831a"}
    )
    
    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # seconds
    POLL_INTERVAL = 1  # second
    
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()
    
    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )
        
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")
        
        prediction = response.json()
        
        if prediction["status"] == "succeeded":
            return prediction["output"]
        
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")
```

#### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "How engineers see the San Francisco Bridge",
      "resolution": "2K",
      "aspect_ratio": "4:3",
      "output_format": "png",
      "safety_filter_level": "block_only_high"
    },
    "version": "81a5073adeced23b51ae9f85cd86c88954e7f25d7894eea0c7ebbc0c24d6831a"
  }'

# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/image-generation-editing-google-nano-banana-pro/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization

- Optimize your image generation requests by using specific and detailed prompts.
- Utilize appropriate resolution and format to balance image quality and processing time.
- Implement efficient error handling and retry strategies to minimize downtime and resource usage.

## FAQ

### What is Nano-Banana-Pro?

Nano-Banana-Pro is an advanced AI model by Google for generating and editing high-quality images based on text prompts and reference images.

### How do I authenticate with the Nano-Banana-Pro API?

Use an API key provided by API.market. Include your API key in the request header as `x-api-market-key`.

### What output formats does Nano-Banana-Pro support?

Nano-Banana-Pro supports JPG and PNG output formats.

### How are prediction status updates handled?

Predictions are processed asynchronously. Use the prediction ID returned from the POST request to poll the GET endpoint until the prediction is completed.

### What are the available safety filter levels?

There are three safety filter levels:
- block_low_and_above
- block_medium_and_above
- block_only_high

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello[at]api.market.

Generate and edit high-quality images from text prompts. Flexible aspect ratios. From $0.2/call. Try it free on API.market.