# Apify Opportunity Radar (`bin_ai_tools/apify-product-factory`) Actor

Validate Apify Store opportunities with live demand and competition evidence. Analyze up to 20 keywords or public Actor URLs and receive transparent PASS, WATCH, or REJECT decisions with next-step guidance.

- **URL**: https://apify.com/bin\_ai\_tools/apify-product-factory.md
- **Developed by:** [Bin Bin](https://apify.com/bin_ai_tools) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 opportunity decisions

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

## Apify Opportunity Radar — Build / Watch / Reject

Stop spending development time on Actor ideas that already have strong competition, weak pain evidence, or no repeat-use case.

### v0.2 automated mode

The recommended mode now accepts a **keyword** or a public **Apify Store Actor URL** and queries the public Apify Store API directly. No API token or LLM is required.

For each target it:

- searches relevance-sorted Store results;
- detects likely direct competitors conservatively from core terms in Actor title/name (`repo` is normalized to `repository`);
- reads Store metrics such as total users, 7/30/90-day users, total runs, 30-day run counts, review count/rating, bookmarks and last-run time;
- converts those signals into an explainable `adoptionEvidence` score;
- estimates `saturation` from competitor count, active competitors and strongest competitor adoption;
- returns `PASS`, `WATCH` or `REJECT` with the observed evidence and reason.

Example automated input:

```json
{
  "targets": [
    { "name": "GitHub Repository Monitor", "keyword": "github repository monitor" },
    { "actorUrl": "https://apify.com/apify/web-scraper" }
  ],
  "searchLimit": 20,
  "strictCompetitionGate": true
}
```

`actorUrl` analysis treats the referenced Actor as demand evidence and excludes that exact Actor from the direct-competitor count.

### What it does

Submit 1–20 Apify Actor opportunities and score each one on five practical signals:

- **pain evidence** — is there a clear recurring user problem?
- **repeat use** — would users run this more than once?
- **MVP simplicity** — can the useful version stay narrow and cheap?
- **differentiation** — does the output or workflow materially differ from existing Actors?
- **direct competition** — how many Apify Store products already solve substantially the same problem?

The Actor returns one decision per candidate:

- `PASS` — worth building a smallest testable MVP
- `WATCH` — keep the idea, but collect stronger evidence first
- `REJECT` — do not spend build time unless the evidence changes

### Why this is different

This is not a general market-research scraper. The first version is deliberately a **decision layer** used before development. Its job is to kill duplicate or weak Actor ideas early.

The strict competition gate rejects crowded copies even when their total numeric score looks acceptable.

### Recommended workflow

1. Enter a precise keyword or public Apify Store Actor URL.
2. Run the Radar; it fetches Store evidence automatically and scores adoption/saturation.
3. Inspect the returned direct competitors and evidence, especially when the Store search reports possible truncation.
4. Build only a small differentiated MVP for `PASS`; research `WATCH`; normally drop `REJECT`.
5. If needed, use legacy `candidates` input to preserve the v0.1 manual scoring workflow.

### Example candidates

The included smoke test demonstrates three real decision patterns from the product factory:

- Chrome Extension Ownership Change Monitor — candidate for `PASS` when no direct change-monitor competitor is found.
- WordPress Plugin Supply-chain Drift — `WATCH` when demand is real but adjacent monitoring competition already exists.
- GitHub Actions Tag Drift — `REJECT` when direct Apify security monitors already overlap heavily.

These example inputs are evidence snapshots, not permanently true market claims. Re-check the Store before using them as current facts.

### v0.2 scope

Included:

- keyword or public Store Actor URL input;
- public `/v2/store` lookup with no token;
- direct-competitor filtering from Store search results;
- adoption evidence from users, runs, ratings/reviews and recency;
- saturation scoring;
- explicit sampling fields: `observedDirectCompetitors`, `searchSampleSize`, and `possibleTruncation` so sampled observations are not presented as exact market totals;
- explainable `PASS / WATCH / REJECT` decisions;
- legacy v0.1 manual mode compatibility;
- no LLM and no paid external API.

Current limits:

- Store search is bounded to 1–50 results per target. `observedDirectCompetitors` means direct competitors observed inside `searchSampleSize`, while `possibleTruncation=true` warns that more Store matches existed beyond the sample;
- direct-competitor matching is deterministic token overlap, not semantic LLM judgment;
- the score measures observed Apify-side adoption and competition, not revenue or guaranteed demand;
- external GitHub/web/news/MCP demand evidence is not fetched yet.

### v0.1 compatibility

Included:

- 1–20 candidates per run
- deterministic scoring
- conservative competition gate
- Dataset decision rows
- JSON summary in `OUTPUT`
- no external API key

The legacy v0.1 manual path itself does not do these automatically:

- Apify Store search (v0.2 automated mode now does this)
- web/news crawling
- revenue prediction
- automatic product creation
- LLM-generated market claims

Those should only be added after the decision model proves useful in real product-factory runs.

# Actor input Schema

## `targets` (type: `array`):

Add 1–20 targets. Each object needs either keyword or a public Apify Store actorUrl such as https://apify.com/apify/web-scraper. No manual market scores are required.

## `searchLimit` (type: `integer`):

How many relevance-sorted Apify Store results to inspect for each automated target. Higher values improve coverage but increase response size.

## `candidates` (type: `array`):

Optional legacy mode. Use this instead of targets when you want to provide painEvidence, repeatUse, mvpSimplicity, differentiation and directCompetitors manually.

## `strictCompetitionGate` (type: `boolean`):

When enabled, a market with at least six observed direct competitors and high saturation is rejected automatically.

## Actor input object example

```json
{
  "targets": [
    {
      "name": "GitHub Repository Monitor",
      "keyword": "github repository monitor"
    }
  ],
  "searchLimit": 20,
  "strictCompetitionGate": true
}
```

# Actor output Schema

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

No description

## `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 = {
    "targets": [
        {
            "name": "GitHub Repository Monitor",
            "keyword": "github repository monitor"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bin_ai_tools/apify-product-factory").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 = { "targets": [{
            "name": "GitHub Repository Monitor",
            "keyword": "github repository monitor",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("bin_ai_tools/apify-product-factory").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 '{
  "targets": [
    {
      "name": "GitHub Repository Monitor",
      "keyword": "github repository monitor"
    }
  ]
}' |
apify call bin_ai_tools/apify-product-factory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bin_ai_tools/apify-product-factory"
        }
    }
}
```

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/HH5amMacnuackrfMy/builds/xoNb5jMVgZiCqTiiM/openapi.json