# Analyze Image (`akash9078/analyze-image`) Actor

Unlock powerful AI analysis with just one upload. Detect objects, styles, colors, emotions, and more in seconds. Perfect for designers, researchers, and creators who want to understand images deeply.

- **URL**: https://apify.com/akash9078/analyze-image.md
- **Developed by:** [Akash Kumar Naik](https://apify.com/akash9078) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 54 total users, 13 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.00005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## AI Image Analysis API - Free Image Recognition & Computer Vision Tool

Analyze any image using AI-powered computer vision. Get detailed image descriptions, object detection, and visual content analysis through a simple API. Powered by advanced multimodal AI for accurate image understanding.

### What does AI Image Analyzer do?

**AI Image Analyzer** is an AI-powered image analysis tool that provides comprehensive visual understanding and description of any image. Simply provide an image URL and receive detailed analysis including object identification, scene description, color composition, and contextual interpretation.

This **computer vision API** supports multiple image formats (JPEG, PNG, GIF, WebP) and works with direct URLs and Google Drive links. Built on state-of-the-art vision-language models for production-grade accuracy.

### Why use AI Image Analyzer for image recognition?

#### AI-Powered Visual Analysis
- **Object Detection** - Identify and describe objects, people, and elements in images
- **Scene Understanding** - Get comprehensive descriptions of settings and environments
- **Color & Composition Analysis** - Understand visual elements, lighting, and artistic composition
- **Mood & Emotion Detection** - Extract feelings, atmosphere, and creative interpretations

#### Developer-Friendly Features
- **REST API** - Simple HTTP API for easy integration into any application
- **Multiple Formats** - Supports JPEG, PNG, GIF, WebP, and Google Drive links
- **Fast Processing** - Average processing time of 10-30 seconds per image
- **Flexible Analysis Modes** - Choose from general, detailed, technical, or creative analysis

#### Platform Advantages
- **No Infrastructure Required** - Runs entirely in the cloud
- **Scheduling & Automation** - Set up recurring image analysis tasks
- **API Access** - Integrate with Python, JavaScript, cURL, or any HTTP client
- **Monitoring & Logs** - Track all runs and debug issues easily

### What data can AI Image Analyzer extract?

| Analysis Type | Description | Best For |
|--------------|-------------|----------|
| **General** | Balanced overview of main subjects, setting, and composition | Quick descriptions, content tagging |
| **Detailed** | Comprehensive breakdown of all visual elements | Content moderation, accessibility |
| **Technical** | Image quality, lighting, camera settings assessment | Photography analysis, QC |
| **Creative** | Mood, emotions, story, artistic interpretation | Marketing, creative writing |

#### Output Data Points
- `imageUrl` - Source image URL
- `analysisType` - Mode of analysis used
- `analysisResult` - Detailed AI-generated description
- `modelUsed` - AI model version for reproducibility
- `providerUsed` - AI provider used (nvidia/mistral)
- `processingTime` - Execution duration
- `timestamp` - Analysis timestamp

### How to use AI Image Analyzer API

#### Quick Start Tutorial

1. **Provide image URL** - Input any public image URL or Google Drive link
2. **Select analysis type** - Choose general, detailed, technical, or creative
3. **Run the analysis** - Get instant AI-powered image description
4. **Retrieve results** - Download output in JSON, CSV, or Excel format

#### API Integration Examples

##### Python Example
```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('akash9078/analyze-image').call(run_input={
    'imageUrl': 'https://example.com/image.jpg',
    'analysisType': 'general'
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['analysisResult'])
````

##### JavaScript/Node.js Example

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('akash9078/analyze-image').call({
    imageUrl: 'https://example.com/image.jpg',
    analysisType: 'detailed'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].analysisResult);
```

##### cURL Example

```bash
curl -X POST https://api.apify.com/v2/acts/akash9078~analyze-image/runs \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"imageUrl":"https://example.com/image.jpg","analysisType":"general"}'
```

### How much does AI image analysis cost?

#### Pay-Per-Event Pricing

This Actor uses **pay-per-event pricing**, meaning you only pay for what you use:

| Event | Price | Description |
|-------|-------|-------------|
| Actor Start | $0.00005 | One-time charge per run (first 5 seconds free) |
| API Call | $0.005 | Per image analysis request |

#### Cost Examples

- **1,000 image analyses**: ~$5.05 ($5.00 for API calls + $0.05 for starts)
- **10,000 image analyses**: ~$50.50 ($50.00 for API calls + $0.50 for starts)
- **100,000 image analyses**: ~$505.00 ($500.00 for API calls + $5.00 for starts)

Platform usage costs (compute units) are included in the event pricing.

### Input & Output Examples

#### Input Example

```json
{
    "imageUrl": "https://example.com/fashion-photo.jpg",
    "analysisType": "detailed",
    "customPrompt": "Focus on clothing items and fashion elements"
}
```

#### Output Example

```json
{
    "imageUrl": "https://example.com/fashion-photo.jpg",
    "analysisType": "detailed",
    "analysisResult": "The image features a woman in an elegant setting...",
    "modelUsed": "mistralai/ministral-14b-instruct-2512",
    "providerUsed": "nvidia",
    "processingTime": 22.368,
    "timestamp": "2026-02-25T02:50:27.654Z"
}
```

### AI Image Analysis Use Cases

#### E-commerce & Retail

- **Product Image Tagging** - Auto-generate product descriptions
- **Visual Search** - Create image-based search capabilities
- **Content Moderation** - Automatically review user-uploaded images

#### Media & Publishing

- **Automated Captioning** - Generate alt text for accessibility
- **Content Categorization** - Sort images by content type
- **Thumbnail Selection** - Identify best frames from image sets

#### Marketing & Social Media

- **Brand Monitoring** - Analyze images containing brand elements
- **Sentiment Analysis** - Understand emotional tone of visual content
- **Competitive Analysis** - Compare visual marketing strategies

#### Research & Analytics

- **Data Extraction** - Convert visual data to structured text
- **Trend Analysis** - Identify patterns across image datasets
- **Quality Assessment** - Evaluate image technical quality

### Supported Image Formats

| Format | Support | Notes |
|--------|---------|-------|
| JPEG/JPG | Full | Recommended for photos |
| PNG | Full | Supports transparency |
| GIF | Full | First frame analyzed |
| WebP | Full | Modern compression |
| Google Drive | Full | Automatic link conversion |

### FAQ

#### Is AI image analysis free?

The Actor offers competitive pay-per-event pricing. You only pay for the analyses you run. Check the pricing section above for detailed cost estimates.

#### How accurate is AI image recognition?

The vision-language model provides production-grade accuracy for general image understanding, object detection, and scene description. Accuracy varies based on image quality and complexity.

#### What's the maximum image size?

Images are processed via base64 encoding. Very large images (>10MB) may take longer to process. Recommended image size is under 5MB for optimal performance.

#### Can I analyze multiple images at once?

Currently, the Actor processes one image per run. For bulk processing, use Apify's scheduling and API features to automate multiple runs.

#### Does it support video analysis?

This Actor is designed for static images. For video analysis, consider extracting frames first or using dedicated video analysis tools.

#### Is my image data stored?

Images are processed in real-time and not permanently stored. Analysis results are saved to Apify datasets for retrieval.

#### Can I use custom analysis prompts?

Yes! Use the `customPrompt` parameter to override default analysis instructions with your specific requirements.

### Technical Specifications

#### System Requirements

- **Memory**: 256MB minimum
- **Timeout**: Up to 180 seconds per image
- **Concurrency**: Based on Apify plan limits

#### API Endpoints

- **Run Actor**: `POST /v2/acts/akash9078~analyze-image/runs`
- **Get Results**: `GET /v2/datasets/{datasetId}/items`

### Support & Resources

#### Need Help?

- **Issues Tab**: Report bugs or request features directly on the Actor page
- **Apify Documentation**: [docs.apify.com](https://docs.apify.com)

#### Related Actors

- Image scrapers for collecting images from websites
- OCR tools for text extraction from images
- Data enrichment Actors for combining image analysis with other data

### Legal & Disclaimer

Users are responsible for:

- Ensuring they have rights to analyze images
- Compliance with applicable terms of service
- Adherence to applicable privacy and data protection laws

Personal data extracted from images may be subject to GDPR and other regulations. Always ensure legitimate use cases for image analysis.

***

**Built with** [Apify](https://apify.com) - The platform for web scraping and automation.

# Actor input Schema

## `imageUrl` (type: `string`):

URL of the image to analyze (supports JPEG, PNG, GIF, WebP, and Google Drive links)

## `analysisType` (type: `string`):

Type of analysis to perform on the image

## `customPrompt` (type: `string`):

Custom prompt for image analysis. If provided, this will be used instead of the analysis type.

## Actor input object example

```json
{
  "imageUrl": "https://i.pinimg.com/1200x/29/fd/57/29fd57209e675bed7b0df4551e2f35fe.jpg",
  "analysisType": "general",
  "customPrompt": "Describe this image in detail, including the main subjects, setting, colors, and overall composition."
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing image analysis results

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrl": "https://i.pinimg.com/1200x/29/fd/57/29fd57209e675bed7b0df4551e2f35fe.jpg",
    "analysisType": "general",
    "customPrompt": "Describe this image in detail, including the main subjects, setting, colors, and overall composition."
};

// Run the Actor and wait for it to finish
const run = await client.actor("akash9078/analyze-image").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrl": "https://i.pinimg.com/1200x/29/fd/57/29fd57209e675bed7b0df4551e2f35fe.jpg",
    "analysisType": "general",
    "customPrompt": "Describe this image in detail, including the main subjects, setting, colors, and overall composition.",
}

# Run the Actor and wait for it to finish
run = client.actor("akash9078/analyze-image").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrl": "https://i.pinimg.com/1200x/29/fd/57/29fd57209e675bed7b0df4551e2f35fe.jpg",
  "analysisType": "general",
  "customPrompt": "Describe this image in detail, including the main subjects, setting, colors, and overall composition."
}' |
apify call akash9078/analyze-image --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=akash9078/analyze-image",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Analyze Image",
        "description": "Unlock powerful AI analysis with just one upload. Detect objects, styles, colors, emotions, and more in seconds. Perfect for designers, researchers, and creators who want to understand images deeply.",
        "version": "1.0",
        "x-build-id": "tGnlQWwOhjV1CW0yg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/akash9078~analyze-image/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-akash9078-analyze-image",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/akash9078~analyze-image/runs": {
            "post": {
                "operationId": "runs-sync-akash9078-analyze-image",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/akash9078~analyze-image/run-sync": {
            "post": {
                "operationId": "run-sync-akash9078-analyze-image",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "imageUrl"
                ],
                "properties": {
                    "imageUrl": {
                        "title": "Image URL",
                        "type": "string",
                        "description": "URL of the image to analyze (supports JPEG, PNG, GIF, WebP, and Google Drive links)"
                    },
                    "analysisType": {
                        "title": "Analysis Type",
                        "enum": [
                            "general",
                            "detailed",
                            "technical",
                            "creative"
                        ],
                        "type": "string",
                        "description": "Type of analysis to perform on the image",
                        "default": "general"
                    },
                    "customPrompt": {
                        "title": "Custom Prompt",
                        "type": "string",
                        "description": "Custom prompt for image analysis. If provided, this will be used instead of the analysis type."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```