# AI Product Opportunity Finder (`piotrv1001/ai-product-opportunity-finder`) Actor

The AI Product Opportunity Finder scrapes real customer reviews from Amazon product pages and uses AI to surface top strengths, repeated complaints, unmet needs, listing improvements, marketing angles, and cross-product comparisons — ideal for Amazon sellers, brands, and product researchers.

- **URL**: https://apify.com/piotrv1001/ai-product-opportunity-finder.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** AI, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 reviews

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 Product Opportunity Finder

Turn real customer reviews into **decision-ready product insights**. The **AI Product Opportunity Finder** scrapes reviews from product listings and uses an LLM to surface top strengths, repeated complaints, unmet needs, listing ideas, and (optionally) a competitor comparison across up to 5 products. Amazon is supported today — more review sources coming.

### ✨ Features

- 🔍 **Real review extraction** — pulls customer reviews embedded on each Amazon product page.
- 🧠 **AI-powered insights** — repeated strengths, repeated complaints, unmet needs, themes with sentiment, listing suggestions, and marketing angles.
- ⚔️ **Competitor comparison** — optional cross-product summary with common complaints across the market and differentiation opportunities.
- 🛡️ **Graceful failure** — one bad URL doesn't stop the run; failed products emit an `error` row.
- 🌍 **Any output language** — set `outputLanguage` to get summaries in your preferred language.

### 🛠️ How It Works

1. **Paste Amazon product URLs** – 1 to 5 `/dp/ASIN` URLs.
2. **Run the actor** – it scrapes each product, extracts reviews, and calls the LLM for analysis.
3. **Read the insights** – structured JSON rows land in the run's dataset, ready to download or integrate.

### 📥 Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `productUrls` | `string[]` (1–5) | — | Amazon product URLs in `/dp/ASIN` format. **Required.** |
| `maxReviewsPerProduct` | `integer` (1–50) | `20` | Cap on reviews analyzed per product. Amazon embeds ~6–8 reviews per product page, so larger values rarely change the output. |
| `sortBy` | `"recent" \| "helpful"` | `"recent"` | Review sort order on Amazon. |
| `analysisMode` | `"product_insights" \| "competitor_comparison"` | `"product_insights"` | Set to `competitor_comparison` to also get a cross-product comparison row. |
| `outputLanguage` | `string` | `"English"` | Language for AI-generated summaries. |

Example input:

```json
{
    "productUrls": [
        "https://www.amazon.com/dp/B09B8V1LZ3"
    ],
    "maxReviewsPerProduct": 20,
    "analysisMode": "product_insights",
    "outputLanguage": "English"
}
````

### 📊 Sample Output Data

The actor pushes three row types to the dataset, distinguished by `type`: `raw_review`, `product_insights`, and (optionally) `competitor_comparison`. Example `product_insights` row:

```json
{
    "type": "product_insights",
    "productId": "amazon:B09B8V1LZ3",
    "asin": "B09B8V1LZ3",
    "productTitle": "Amazon Echo Dot (newest model)",
    "brand": "Amazon",
    "source": "amazon",
    "reviewCountAnalyzed": 6,
    "overallSummary": "Customers appreciate the sound quality and ease of setup, but some feel it's overpriced and miss the audio jack.",
    "topStrengths": [
        "Clear and vibrant sound quality",
        "Easy and quick setup process",
        "Good integration with Alexa and smart home devices"
    ],
    "topComplaints": [
        "Perceived as overpriced for the features",
        "Missing 3.5mm audio jack"
    ],
    "unmetNeeds": [
        "Reintroduction of the audio jack",
        "More competitive pricing"
    ],
    "themes": [
        { "theme": "Sound Quality", "sentiment": "positive", "summary": "Customers are impressed with the sound clarity and volume." }
    ],
    "listingSuggestions": [
        "Highlight sound quality and setup ease in the product description"
    ],
    "marketingAngles": [
        "Perfect for music lovers and smart home enthusiasts"
    ]
}
```

### 💰 Pricing

This actor uses **Pay Per Event (PPE)** pricing with two chargeable events:

| Event | When it fires | Price |
| --- | --- | --- |
| `review-scraped` | Charged once per Amazon review successfully extracted and pushed to the dataset. | **$1.00 / 1000 reviews** |
| `insights-generated` | Charged once per successful AI output row — one per product, plus one more row if `competitor_comparison` mode is used with ≥2 products. | **$20.00 / 1000 rows** |

A typical run of **3 products** (~6 reviews each) costs roughly `18 × $0.001 + 3 × $0.02 ≈ $0.08`. Failed products and fallback AI rows (emitted when the LLM call fails) are **not** charged.

Uncover your next product opportunity with **AI Product Opportunity Finder** today! 🚀

# Actor input Schema

## `productUrls` (type: `array`):

List of Amazon product URLs to analyze (up to 5). Each URL should point to a product page (/dp/ASIN).

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to analyze per product. Amazon exposes around 6–8 reviews on each product page, so values above ~10 rarely have an effect.

## `sortBy` (type: `string`):

Order in which Amazon returns reviews.

## `analysisMode` (type: `string`):

Analyze each product separately, or run an additional cross-product comparison.

## `outputLanguage` (type: `string`):

Language for AI-generated summaries.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B09B8V1LZ3"
  ],
  "maxReviewsPerProduct": 20,
  "sortBy": "recent",
  "analysisMode": "product_insights",
  "outputLanguage": "English"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "productUrls": [
        "https://www.amazon.com/dp/B09B8V1LZ3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/ai-product-opportunity-finder").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 = { "productUrls": ["https://www.amazon.com/dp/B09B8V1LZ3"] }

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/ai-product-opportunity-finder").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 '{
  "productUrls": [
    "https://www.amazon.com/dp/B09B8V1LZ3"
  ]
}' |
apify call piotrv1001/ai-product-opportunity-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=piotrv1001/ai-product-opportunity-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Product Opportunity Finder",
        "description": "The AI Product Opportunity Finder scrapes real customer reviews from Amazon product pages and uses AI to surface top strengths, repeated complaints, unmet needs, listing improvements, marketing angles, and cross-product comparisons — ideal for Amazon sellers, brands, and product researchers.",
        "version": "0.0",
        "x-build-id": "no6qRpG70ywmMk846"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~ai-product-opportunity-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-ai-product-opportunity-finder",
                "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/piotrv1001~ai-product-opportunity-finder/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-ai-product-opportunity-finder",
                "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/piotrv1001~ai-product-opportunity-finder/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-ai-product-opportunity-finder",
                "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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Amazon product URLs",
                        "minItems": 1,
                        "maxItems": 5,
                        "type": "array",
                        "description": "List of Amazon product URLs to analyze (up to 5). Each URL should point to a product page (/dp/ASIN).",
                        "default": [
                            "https://www.amazon.com/dp/B09B8V1LZ3"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of reviews to analyze per product. Amazon exposes around 6–8 reviews on each product page, so values above ~10 rarely have an effect.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Review sort order",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order in which Amazon returns reviews.",
                        "default": "recent"
                    },
                    "analysisMode": {
                        "title": "Analysis mode",
                        "enum": [
                            "product_insights",
                            "competitor_comparison"
                        ],
                        "type": "string",
                        "description": "Analyze each product separately, or run an additional cross-product comparison.",
                        "default": "product_insights"
                    },
                    "outputLanguage": {
                        "title": "Output language",
                        "type": "string",
                        "description": "Language for AI-generated summaries.",
                        "default": "English"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
