# Amazon Product Research & Niche Analyzer (`jin_data_tools/amazon-niche-opportunity-auditor`) Actor

Compare Amazon niches using your product data or an Apify Dataset. Analyze brand competition, review barriers, prices and demand signals. $0.10 per qualifying analysis; no analysis fee for demo or insufficient data. Does not scrape Amazon.

- **URL**: https://apify.com/jin\_data\_tools/amazon-niche-opportunity-auditor.md
- **Developed by:** [Jin Murata](https://apify.com/jin_data_tools) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$100.00 / 1,000 completed analyses

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Amazon Product Research & Niche Analyzer

Turn Amazon product rows into a structured niche comparison: demand signals, brand concentration, review barriers, price distribution and data-quality warnings.

For Amazon sellers, researchers and automation builders who already have product data and want a consistent first-pass comparison before deeper research. This Actor does not scrape Amazon or buy data. Use data you are authorized to process.

### Pricing at a glance

**$0.10 per completed, qualifying analysis — not per product row.** One run analyzes one niche with up to 200 product rows. Demo runs and `INSUFFICIENT_DATA` results do not trigger the analysis fee. Set a run budget of at least $0.10 for qualifying analyses.

### What you can check

| Research question | Report evidence |
|---|---|
| Is the sample dominated by a few brands? | Brand concentration and possible product-family groupings |
| Do established listings have a large review advantage? | Review-count statistics |
| What price range does this sample cover? | Price distribution |
| Are demand signals available? | Supplied BSR and recent-purchase signals, plus missing-data warnings |

Use this as a repeatable first-pass screening step for existing product data. It does not calculate profit or guarantee a profitable niche.

### Try a sample first

In the input form, select **Demo (bundled sample)** and start the Actor. No product data or API token is needed for this demo. The sample is synthetic, and the analysis fee is zero.

If you prefer JSON:

```json
{"mode": "demo", "demoFixture": "sufficient_market"}
```

Open **Analysis results** for the dataset or **Full JSON report** for the complete result. A run produces one analysis record containing the analyzed product rows.

The bundled example has 10 valid rows and returns an `OPPORTUNITY` label. These are synthetic demonstration results, not current Amazon market findings or evidence of profitability.

To see the insufficient-data response:

```json
{"mode": "demo", "demoFixture": "owala_insufficient"}
```

### Analyze your own data

Choose one data source per run.

| Mode | What you supply | Data access |
|---|---|---|
| `demo` | Nothing; optionally select a fixture | Bundled sample only |
| `products` | Keyword and a non-empty array of product objects | Processes supplied rows |
| `dataset` | Keyword and your existing Apify Dataset ID | Reads up to the requested limit from that dataset |

For products, use the following shape with your actual data. This two-row synthetic example intentionally cannot support a niche conclusion:

```json
{
  "mode": "products",
  "keyword": "example niche",
  "maxProducts": 2,
  "products": [
    {"asin": "B0EXAMPLE1", "title": "Example product A", "brand": "Example A", "price": 20, "reviewCount": 100},
    {"asin": "B0EXAMPLE2", "title": "Example product B", "brand": "Example B", "price": 25, "reviewCount": 200}
  ]
}
```

For an existing dataset:

```json
{
  "mode": "dataset",
  "keyword": "your niche",
  "sourceDatasetId": "YOUR_DATASET_ID",
  "maxProducts": 30
}
```

The run must have permission to read that dataset. Do not paste API tokens into the input. For local dataset runs, configure `APIFY_TOKEN` in your execution environment.

Useful fields include `asin`, `title`, `brand`, `price`, `reviewCount`, `bsr` and `boughtInPastMonth`. Omit unavailable values or use null. Do not invent values to improve the score.

### Connect a product dataset to your research workflow

1. Collect a relevant niche sample using your existing data source.
2. Check that each row contains `asin` and `title`. Useful additional fields are `brand`, `price`, `reviewCount`, `bsr` and `boughtInPastMonth`. A different scraper's output may require field mapping.
3. Copy that run's default Dataset ID into **Apify Dataset ID**, select **Dataset** mode, and enter a niche label.
4. Set **Max products to analyze** to the sample size you intend to read (up to 200), then run the analysis.
5. Inspect the evidence and warnings before comparing candidates. Keep sampling methods and marketplaces consistent across comparisons.

For a useful conclusion, the engine requires at least **8 valid products and 3 distinct product families**, plus sufficient completeness and sample coverage. Meeting the row count alone does not guarantee a qualifying analysis.

To automate repeated research, run your data-collection step first, pass its dataset ID as `sourceDatasetId`, and run this Actor once per niche. This is a workflow recipe; compatibility with every upstream scraper has not been tested. This Actor itself does not start the collection step or refresh the source dataset.

### Use Junglee Amazon Product Scraper output

Already collecting products with [Junglee Amazon Product Scraper](https://apify.com/junglee/amazon-crawler)? Pass its default Dataset ID to this Actor in Dataset mode. No manual reshaping is needed for the documented fields below.

| Collector field | Used as |
|---|---|
| `price.value` | Numeric price |
| `stars` | Rating, when a canonical rating is not supplied |
| `reviewsCount` | Review count |
| `seller.name` | Seller name |
| `breadCrumbs` | Category path |

The adapter keeps missing values missing, records mapped-row counts in `actor_meta.upstream_mapping`, and rejects conflicting explicit price currencies. It does not convert currencies or infer sales. Use one niche and one marketplace per run. These mappings are independently implemented; this product is not endorsed by Junglee.

#### Chain collection and analysis

In the collector's **Integrations** tab, configure **Run Actor** to start this Actor after a successful run. Use the following input with string interpolation enabled:

```json
{
  "mode": "dataset",
  "keyword": "your collection niche",
  "marketplace": "com",
  "sourceDatasetId": "{{resource.defaultDatasetId}}",
  "maxProducts": 10
}
```

Set `maxProducts` to your intended sample size, up to 200. The example uses 10 to keep the initial test small. Set the target run to latest, 256 MB, 60 seconds and a $0.10 maximum event charge. The collector's own charges are separate. A successful collection can still produce insufficient data; inspect the output before making a decision.

See [Apify's Actor-to-Actor integration instructions](https://docs.apify.com/integrations/actors) for event variables and test controls. Configure the link once in your own account; this Analyzer never launches or pays for the upstream scraper itself. Webhook delivery can be duplicated, so inspect duplicate triggers before retrying; billing is once per qualifying run, not deduplicated across separate runs.

[Try the synthetic sample first](https://apify.com/jin_data_tools/amazon-niche-opportunity-auditor/examples/amazon-niche-analysis-demo-synthetic-sample).

### Read the result

| Result | How to use it |
|---|---|
| `OPPORTUNITY` | Candidate for further research under the current heuristic |
| `NEUTRAL` | Mixed signals; inspect the supporting evidence |
| `CROWDED` | Competition signals warrant closer investigation |
| `INSUFFICIENT_DATA` | Sample quality or diversity is inadequate; inspect the listed reasons |

The report includes data completeness, possible product-family groupings, price statistics, demand proxies, confidence and the thresholds used. Scores and confidence are heuristic indicators, not calibrated success probabilities. Demand proxies are not verified sales. Thresholds are provisional and have not been validated against customer business outcomes.

### Limits and costs

- One keyword/niche per run; maximum 200 rows.
- Console/API input schema accepts `maxProducts` from 1 to 200. Direct wrapper calls above 200 are capped and disclosed in `actor_meta`.
- Only the first requested dataset rows are read; this is not a random or representative market sample.
- No paid upstream Actor is started.
- Active analysis price: USD 0.10 per completed non-demo analysis with sufficient data, once per run. Demo and INSUFFICIENT\_DATA outputs do not trigger this analysis fee. The Store pricing tab shows the current price.
- With pay-per-event-only pricing, platform usage is not added to the user's event bill. Platform costs can still affect developer proceeds; this is not a promise of zero operating costs.
- If the run budget is below the event price, the billable report is not delivered or charged. Results are saved before the charge request. An uncertain billing response stops the run and is not automatically retried; contact support with the run ID. A saved report may remain available even when charging fails.
- Results do not include sourcing costs, shipping, advertising, Amazon fees or net profit.

### Data handling

On Apify, inputs and outputs are handled by the platform. The Actor writes its full analysis, including normalized product rows, to the run dataset and the OUTPUT key-value record. Storage retention and access follow your platform settings; data is not guaranteed to disappear when a run ends.

The code also writes local usage events containing the keyword, marketplace, outcome and an optional customer reference. This local file is not a verified cross-run customer or payment ledger. Avoid personal or confidential information in keywords and input rows.

### Troubleshooting

- Rejected input: check mode, field types and product rows.
- Dataset access failure: check the ID and the run's permissions.
- Insufficient data: inspect the report's reasons; add relevant, diverse, complete rows instead of filling missing values with guesses.
- Unexpected label: inspect thresholds and evidence before using the result.

Use the Actor's Issues tab for support. Share a redacted input example and the error message, never tokens or confidential datasets.

# Actor input Schema

## `mode` (type: `string`):

Choose bundled demo data, product rows you supply, or an existing dataset. This Actor does not scrape Amazon.

## `keyword` (type: `string`):

Required for 'products' and 'dataset' modes. Used only as a label in the output -- never sent anywhere.

## `marketplace` (type: `string`):

Amazon locale code, e.g. 'com', 'co.uk', 'de'. Recorded in output only; the Actor does not query Amazon.

## `maxProducts` (type: `integer`):

Explicit cap on rows analyzed. Hard platform ceiling is 200 regardless of this value; requests above the ceiling are capped and disclosed in actor\_meta.max\_products\_capped, never silently truncated without notice.

## `demoFixture` (type: `string`):

Choose a bundled example to inspect the output; demo results are not live market research.

## `products` (type: `array`):

Raw product rows you already have (e.g. from your own Amazon-data source). Required, non-empty, when mode=products. Missing optional fields must be omitted or null -- never fabricate a value to fill a gap.

## `sourceDatasetId` (type: `string`):

Select your existing product dataset. This run receives read-only access to that selected dataset; the Actor does not start a scraper or modify the source.

## Actor input object example

```json
{
  "mode": "demo",
  "marketplace": "com",
  "demoFixture": "sufficient_market"
}
```

# Actor output Schema

## `analysis` (type: `string`):

One analysis record with evidence, confidence and data-quality warnings. Demo records are sample data.

## `report` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jin_data_tools/amazon-niche-opportunity-auditor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("jin_data_tools/amazon-niche-opportunity-auditor").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 '{}' |
apify call jin_data_tools/amazon-niche-opportunity-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jin_data_tools/amazon-niche-opportunity-auditor"
        }
    }
}

```

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/D4n6Eg7jUEh68BWSF/builds/b3xzq6grghKk9Q569/openapi.json