# 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
- **Features:** Limited permissions
- **Stats:** 160 total users, 19 monthly users, 100.0% runs succeeded, 5 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Analyze Image** is an Apify Actor that **analyzes any image with AI-powered computer vision** and returns detailed descriptions, object identification, and scene understanding through a simple API. Provide an image URL, choose an **analysis type** — general, detailed, technical, or creative — and get structured results in **10-30 seconds**. Powered by advanced vision-language models for production-grade image understanding.

### What Is Analyze Image?

Analyze Image is an AI-powered image analysis API 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. Results include the model and provider used, so every analysis is reproducible.

### Key Features

- **Object Detection** — identify and describe objects, people, and elements in images
- **Scene Understanding** — 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
- **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** — general, detailed, technical, or creative analysis
- **No Infrastructure Required** — runs entirely in the cloud with scheduling, monitoring, and logs

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

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

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `imageUrl` | string | Yes | — | URL of the image to analyze (JPEG, PNG, GIF, WebP, Google Drive links) |
| `analysisType` | string | No | `general` | `general`, `detailed`, `technical`, or `creative` |
| `customPrompt` | string | No | — | Custom prompt used instead of the analysis type |

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

Example input:

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

### Sample Output

```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"
}
```

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 the Analyze Image Actor

1. Open the [Actor page on Apify Store](https://apify.com/akash9078/analyze-image) and click **Start Actor**.
2. Input any public image URL or Google Drive link into `imageUrl`.
3. Select an `analysisType` (general, detailed, technical, or creative) or provide a `customPrompt`.
4. Run the analysis and download output in JSON, CSV, or Excel format.

#### Connect via API

cURL:

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

Python:

```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'])
```

Node.js with the [Apify Client](https://docs.apify.com/api/client/js):

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

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

### Why Use This Instead of Building Your Own Vision Pipeline?

| Capability | Analyze Image | DIY vision pipeline |
|------------|---------------|---------------------|
| Setup | Paste a URL and run | Model hosting, GPU ops |
| Analysis modes | 4 built-in modes + custom prompt | You write every prompt |
| Reproducibility | `modelUsed`/`providerUsed` fields | Manual tracking |
| Batch automation | Schedules and API built in | Custom orchestration |
| Cost model | $0.005 per analysis, pay per event | Fixed GPU costs |

### Limitations

- Processes **one image per run**; use Apify scheduling and the API to automate multiple runs
- Images are processed via base64 encoding — very large images (>10MB) take longer; under 5MB is recommended
- Designed for static images only (GIF: first frame analyzed)
- Memory: 256MB; timeout up to 180 seconds per image

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

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

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

### Related Actors

If you need more image intelligence tools from Apify, check out my other [Apify Actors](https://apify.com/akash9078):

- [AI Background Remover - HD & Transparent](https://apify.com/akash9078/ai-bg-remover)
- [AI Image Upscaler & Face Enhancer](https://apify.com/akash9078/ai-image-upscaler)
- [AI Face Swap](https://apify.com/akash9078/ai-face-swap)
- [Frame Image Converter](https://apify.com/akash9078/frame-image-converter)
- [Image Format Converter](https://apify.com/akash9078/image-format-converter)

***

Built and maintained by [akash9078](https://apify.com/akash9078) on the [Apify platform](https://docs.apify.com).

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,akash9078/analyze-image"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/piSzHj8g1c8acGpHI/builds/VvRdKciH8XIgMD6as/openapi.json