Name: Visual Q&A – Answer Questions on Images | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-image-question-answering-ai-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ Advanced Image Question Answering API (Blip 3 / XGen-MM)

## Overview
The Advanced Image Question Answering API enables you to ask questions about an image and receive detailed, context-aware answers. By leveraging powerful AI models (Blip 3 / XGen-MM), this API allows for sophisticated understanding of images, making it ideal for automation, content analysis, and other image-based workflows.

This API can handle:
- Simple queries like “What is in this image?”
- More advanced context-based queries that consider prior Q&A exchanges
- Instruction-based prompts for generating image captions

## Features
- Immediate, context-rich answers to questions about images
- Optional image captioning functionality
- Fine-grained controls over generation (sampling, beams, temperature, etc.)
- Asynchronous processing for complex queries
- High accuracy in visual identification and understanding

## Use Cases
1. Automated content moderation: Quickly identify objects, text, or other content within images for compliance checks.  
2. E-commerce: Provide users with product information or comparisons by showing images and asking questions.  
3. Accessibility: Generate image descriptions for visually impaired users.  
4. Creative projects: Brainstorm with AI-generated captions or answers for images.  
5. Data enrichment: Tag or catalog large image collections with semantic metadata.

## Visual Examples

Below is an example of an input image taken from the schema examples:

![Example input image: A meme to be explained by the AI](https://replicate.delivery/pbxt/KtaXKzjetYsIqKFZoJPiX9SP8IVJEiCTIAXn1DZbmLp5iQCJ/image.png)

In a typical request, you can send this image along with a question like “Can you explain this meme?” The API will then analyze the image and generate a text-based answer.

## Pricing
- 1 API unit equals 1 image processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/image-question-answering-ai-api/predictions/{id}) are free and do not count toward API unit usage.  
- Different pricing tiers are available based on usage volume.  

For specific pricing plans and details, refer to the API.market pricing page.

## API Documentation

### Base URL
All requests to this API should be made to:  
```
https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api
```

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
This key is provided by API.market. Keep it secure, and do not expose it publicly.

### Asynchronous Processing
This API uses asynchronous processing to handle predictions. The typical flow is:
1. Submit a prediction request (POST /api/v1/magicapi/image-question-answering-ai-api/predictions)  
2. The response contains a unique prediction ID  
3. Poll the GET endpoint (GET /api/v1/magicapi/image-question-answering-ai-api/predictions/{id}) to retrieve status and results  
4. Continue polling until the status is "succeeded" (or "failed")  

Use a polling interval of approximately 1 second and a maximum timeout of 600 seconds (10 minutes). This gives the model enough time to process and return results for complex queries.

### Endpoints

---

#### POST /api/v1/magicapi/image-question-answering-ai-api/predictions

Create a new prediction to get answers or captions for your image.

• Request Body Parameters  
  - version (string)  
    - Model version ID  
    - Default: 499bec581d8f64060fd695ec0c34d7595c6824c4118259aa8b0788e0d2d903e1  
  - input (object)  
    - image (required): URL of the input image  
      - Example: "https://example.com/image.jpg"  
    - question: Question to ask about the image  
    - caption: (boolean) Whether to generate a caption instead of question-based answers  
    - context: (string) Previous Q&A or contextual information for multi-turn conversations  
    - Additional generation parameters (num_beams, temperature, etc.)

• Response Fields  
  - id (string): Unique identifier for the newly created prediction  
  - version (string): Model version used for the prediction  
  - status (string): Current status of the prediction (starting, processing, succeeded, failed, canceled)  
  - created_at (string): Timestamp when the prediction was created  

Example request using cURL:

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "499bec581d8f64060fd695ec0c34d7595c6824c4118259aa8b0788e0d2d903e1",
    "input": {
      "image": "https://example.com/image.jpg",
      "question": "What is shown in this picture?"
    }
  }'
```

Example successful response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "499bec581d8f64060fd695ec0c34d7595c6824c4118259aa8b0788e0d2d903e1",
  "status": "starting",
  "created_at": "2025-04-22T22:38:37.117Z"
}
```

---

#### GET /api/v1/magicapi/image-question-answering-ai-api/predictions/{id}

Retrieve the status and results of a prediction.

• Path Parameters  
  - id (string)  
    - The unique prediction ID returned when the prediction was created  

• Response Fields  
  - id (string): Unique identifier for the prediction  
  - status (string): Current status (starting, processing, succeeded, failed, canceled)  
  - output (string): AI-generated answer or caption (if succeeded)  
  - error (string): Error message if the prediction failed  
  - created_at, started_at, completed_at: Timestamps for relevant events in the prediction lifecycle  

Example request using cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example successful response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "The meme is a humorous representation of ...",
  "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 was successful.  
• 201 Created: Prediction created successfully.  
• 400 Bad Request: Invalid input parameters or malformed request.  
• 401 Unauthorized: Missing or invalid API key.  
• 403 Forbidden: Valid API key, but insufficient permissions to access resource.  
• 404 Not Found: Resource not found.  
• 429 Too Many Requests: Rate limit exceeded.  
• 500 Internal Server Error: A server-side error occurred.  
• 503 Service Unavailable: Service is temporarily unavailable or overloaded.

## Rate Limits
API requests may be subject to rate limiting based on your plan. If you exceed your plan’s request limits, you will receive a 429 Too Many Requests error. If you anticipate high volumes of requests, consider upgrading your plan for higher rate limits.

## Error Handling
When an error occurs, the API returns a JSON payload describing the issue. For example:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
Best practices:
- Check the "code" and "message" fields to determine the cause of the error.  
- Retry only for transient errors (e.g., timeouts or 429 Too Many Requests).  
- For invalid parameters or 400-series errors, fix your request before retrying.

## Implementation Guide

### Example Code

Below are some language-specific examples showing how to properly:
1. Authenticate with the API  
2. Submit a prediction request  
3. Poll the status endpoint until the gift arrives  
4. Handle timeouts or failure scenarios  

#### JavaScript Example

```javascript
// JavaScript example with proper polling and timeout

const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-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;

    // Step 2: Poll for results with timeout
    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

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-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");
}

// Usage example:
// createAndWaitForPrediction({ image: "https://example.com/image.jpg" })
//   .then(answer => console.log("Prediction answer:", answer))
//   .catch(err => console.error(err));
```

#### Python Example

```python
# Python example with proper polling and timeout

import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    response = requests.post(f"{BASE_URL}/predictions", json={"input": input_data}, headers=headers)

    if response.status_code != 200 and response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers={"x-magicapi-key": API_KEY})

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


# Usage example:
# answer = create_and_wait_for_prediction({"image": "https://example.com/image.jpg"})
# print("Prediction answer:", answer)
```

#### cURL Example

```bash
# 1) Submit a new prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg"
    }
  }'

# Example response:
# {
#   "id": "abcd1234",
#   "status": "starting"
# }

# 2) Poll the status endpoint (replace abcd1234 with the actual prediction ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/image-question-answering-ai-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Repeat the GET request until "status" is "succeeded" or "failed"
```

### Performance Optimization
- Use smaller images where possible to reduce processing time.  
- Avoid overly long text parameters or unnecessary context.  
- Carefully tune parameters like max_new_tokens, temperature, and beams—smaller values often produce faster results.  
- Batch requests efficiently rather than sending them all at once.

## FAQ
• How fast does it process images?  
  - Typically within a few seconds, but can take longer for complex requests or larger images.  

• Can I just get a caption instead of answering a question?  
  - Yes. Set “caption” to true in your request input to generate an image caption.  

• Do I pay for polling the status endpoint?  
  - No. GET requests for checking prediction status are free.  

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

Ask natural language questions about any image and get AI-powered answers. Supports complex visual reasoning. From $0.05/call. Try it free on API.market.

Visual Q&A – Answer Questions on Images | $0.05/call | API.market

🖼️ Advanced Image Question Answering API (Blip 3 / XGen-MM)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Get instant, accurate answers to visual questions with powerful Blip 3 AI—perfect for image understanding, analysis, and smart automation.