Name: Nano-Banana – Generate & Edit Images | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-image-editing-api-google-nano-banana
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 📸 Ultra-Fast AI Image Editing API (Nano-Banana)

## Overview

The Ultra-Fast AI Image Editing API, powered by Google's Nano-Banana model, seamlessly delivers high-speed and precise image editing capabilities. Built on Google's latest image editing model in Gemini 2.5, this API enables developers and AI engineers to integrate advanced image editing features into their applications with ease.

## Features

- **Lightning-fast Image Processing:** Achieve rapid image edits with minimal latency.
- **High Precision Results:** Delivers high-quality, accurate edits.
- **Versatile Input Options:** Accepts multiple input images and formats (JPG, PNG).
- **Customizable Outputs:** Choose between JPG and PNG output formats.
- **Easy Integration:** Simple REST API design for straightforward implementation.

## Use Cases

1. **E-commerce Product Photo Enhancements:** Optimize product images for online stores by removing backgrounds and enhancing features.
2. **Social Media Application:** Empower users to create captivating posts by allowing advanced image edits directly within your app.
3. **Marketing Campaigns:** Quickly generate and customize promotional images for various marketing needs.
4. **Content Creation Platforms:** Provide content creators with robust tools to enhance and modify their visuals effortlessly.
5. **Augmented Reality Experiences:** Enhance digital objects within AR environments with precise image modifications.

## Visual Examples

### Example Input

![Input Image: Sheets in the style of the logo](https://blog.api.market/wp-content/uploads/2025/12/google-nano-banana-api-market.png)

### Example Output

![Output Image: Edited as per the style of the logo](https://blog.api.market/wp-content/uploads/2025/12/google-nano-banana-output-api-market.jpeg)

### Example Input

![Input Image: Screenshot Image](https://blog.api.market/wp-content/uploads/2025/12/floral-design-api-market.jpg)

## Pricing

- **Pay As You Go (PAYG) pricing**: Pay only for what you use.
- **1 API unit equals 1 image processed**.
- **GET requests to check prediction status** are free and do not 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/ai-image-editing-api-google-nano-banana`

### Authentication

Authentication is handled via API key. Include your API key in the request header:

```http
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. Your code should implement:
- 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.

See the Implementation Guide section for code examples.

### Endpoints

#### POST /api/v1/magicapi/ai-image-editing-api-google-nano-banana/predictions

Create a prediction using the Nano-Banana model.

**Request:**
```json
{
  "version": "f0a9d34b12ad1c1cd76269a844b218ff4e64e128ddaba93e15891f47368958a0",
  "input": {
    "prompt": "Make the sheets in the style of the logo. Make the scene natural.",
    "image_input": [
      "https://blog.api.market/wp-content/uploads/2025/12/google-nano-banana-api-market.png",
      "https://blog.api.market/wp-content/uploads/2025/12/floral-design-api-market.jpg"
    ],
    "output_format": "jpg"
  }
}
```

**Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "f0a9d34b12ad1c1cd76269a844b218ff4e64e128ddaba93e15891f47368958a0",
  "status": "starting",
  "created_at": "2025-09-02T11:37:20.434Z"
}
```

#### GET /api/v1/magicapi/ai-image-editing-api-google-nano-banana/predictions/{id}

Get prediction status and results.

**Request:**
```http
GET /api/v1/magicapi/ai-image-editing-api-google-nano-banana/predictions/ufawqhfynnddngldkgtslldrkq
```

**Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/google-nano-banana-output-api-market.jpeg",
  "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

- Rate limit policies are in place to protect API availability and performance.
- The exact rate limits vary depending on the usage plan.
- For best practices, incorporate exponential backoff and retry strategies for rate-limited requests.

### Error Handling

Handle errors by interpreting response codes and retrying when appropriate. Here is an example of a typical error response:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code

#### JavaScript

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

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

    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 (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second between checks

  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

```python
import requests
import time

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

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}
    )
    
    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  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second between checks
    
    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

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-image-editing-api-google-nano-banana/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "f0a9d34b12ad1c1cd76269a844b218ff4e64e128ddaba93e15891f47368958a0",
    "input": {
      "prompt": "Make the sheets in the style of the logo. Make the scene natural.",
      "image_input": [
        "https://blog.api.market/wp-content/uploads/2025/12/google-nano-banana-api-market.png"
      ],
      "output_format": "jpg"
    }
  }'

# Response will contain a prediction ID like:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-image-editing-api-google-nano-banana/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: You need to repeatedly poll this endpoint manually until status is "succeeded"
```

### Performance Optimization

- Use efficient polling strategies with appropriate intervals to avoid overwhelming the API.
- Ensure your code handles rate limits gracefully by implementing exponential backoff.
- Process images in batches to optimize API usage and reduce costs.

## FAQ

1. **What input formats are supported?**
   - The API supports JPG and PNG input formats.

2. **How long does it take to process an image?**
   - Processing time varies based on complexity, but typically ranges from a few seconds to a couple of minutes.

3. **Are there any usage limits?**
   - There are no monthly subscription fees or usage limits. The API operates on a pay-as-you-go model.

4. **Can I use this API for commercial purposes?**
   - Yes, the API is designed to be used in both personal and commercial applications.

## 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 images with Google's Gemini 2.5 model. Get high-speed, precise results. From $0.05/call. Try it free on API.market.

Nano-Banana – Generate & Edit Images | $0.05/call | API.market

📸 Ultra-Fast AI Image Editing API (Nano-Banana)

PAYG

MagicAPI

Google's Nano Banana is mind blowing, its actually really good. Works well.