# Apify Store Opportunity Finder: Lead Gen Edition (`adamjosh/apify-store-opportunity-finder`) Actor

Find Apify Actor ideas by analyzing public Store demand, saturation, weak competitors, and lead-gen niche gaps.

- **URL**: https://apify.com/adamjosh/apify-store-opportunity-finder.md
- **Developed by:** [Adam Josh](https://apify.com/adamjosh) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Apify Store Opportunity Finder: Lead Gen Edition

Find profitable Apify Actor ideas before building another generic lead-gen scraper.

This Actor searches public Apify Store listings, normalizes Actor metadata, classifies lead-gen niches, and generates opportunity reports based on demand, saturation, ratings, weak positioning, and public usage signals.

### What It Does

- Searches Apify Store with your keywords.
- Exports normalized Actor rows.
- Detects platforms like LinkedIn, Twitter/X, Instagram, Facebook, YouTube, Google Maps, Trustpilot, and Glassdoor.
- Detects use cases like lead generation, contact extraction, monitoring, reviews, jobs, ecommerce, ads, and enrichment.
- Groups Actors into niches.
- Scores demand, weakness, saturation, and opportunity.
- Writes a markdown summary to `SUMMARY.md`.

### Who It Is For

- Apify Actor developers
- scraping agencies
- indie hackers
- data product builders
- lead-gen operators deciding what scraper to build next

### Input

```json
{
  "searchTerms": ["lead generation", "linkedin scraper", "google maps leads"],
  "maxActorsPerTerm": 200,
  "analysisMode": "market_analysis",
  "sortBy": "popularity",
  "includeRawActors": true,
  "includeNicheReports": true
}
````

### Dataset Output

Actor rows use `record_type: "actor"`:

```json
{
  "record_type": "actor",
  "search_term": "lead generation",
  "actor_id": "example/linkedin-people-search",
  "title": "LinkedIn People Search Scraper",
  "developer": "Example",
  "pricing_model": "PAY_PER_EVENT",
  "rating": 3.2,
  "review_count": 6,
  "total_users": 3000,
  "monthly_users": 180,
  "detected_platforms": ["linkedin"],
  "detected_use_cases": ["lead_generation", "contact_extraction"],
  "quality_flags": ["high_usage_low_rating"]
}
```

Niche rows use `record_type: "niche_report"`:

```json
{
  "record_type": "niche_report",
  "niche": "linkedin lead generation",
  "actors_found": 12,
  "total_users_sum": 18400,
  "median_rating": 3.6,
  "low_rating_high_usage_count": 3,
  "demand_score": 274.13,
  "weakness_score": 42,
  "saturation_score": 58.7,
  "opportunity_score": 257.43,
  "recommended_actor_angle": "LinkedIn lead generation with enrichment, monitoring, and reliability proof"
}
```

### Opportunity Score

The score is a directional ranking, not a promise of profit.

It favors:

- visible demand from public usage and reviews
- weak competitors with poor ratings or weak Store positioning
- niches that are not completely saturated

It penalizes:

- heavy crowding
- strong single-actor dominance
- weak public demand signals

### Monetization Notes

Use Apify Pay Per Event when publishing. This Actor pushes dataset rows with the `store-result` event name, so the simplest setup is one event charged per returned row.

Suggested starting price:

```text
store-result: $0.001 per dataset row
```

Do not manually charge an Actor-start event in code. Apify provides the synthetic start event for new PPE Actors.

### Limitations

- Uses public Apify Store metadata only.
- Does not guarantee demand outside Apify Store.
- Does not scrape private data.
- Does not use LLMs in v1; classification is deterministic keyword matching.
- Scores are a compass for inspection, not financial advice.

### Local Development

```bash
npm install
npm test
npm run lint
npm start
```

For local runs, Apify SDK writes results into the local `storage/` directory.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords or lead-gen niches to analyze in Apify Store.

## `maxActorsPerTerm` (type: `integer`):

Maximum public Store actors to fetch for each search term.

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

Use raw for Store rows only, market\_analysis for grouped scoring, or opportunity\_report for the strongest product output.

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

Sort mode passed to the Apify Store API.

## `category` (type: `string`):

Optional Apify Store category slug.

## `includeRawActors` (type: `boolean`):

Output normalized actor-level rows to the dataset.

## `includeNicheReports` (type: `boolean`):

Output grouped niche-level opportunity rows to the dataset.

## Actor input object example

```json
{
  "searchTerms": [
    "lead generation",
    "linkedin scraper",
    "google maps leads"
  ],
  "maxActorsPerTerm": 200,
  "analysisMode": "market_analysis",
  "sortBy": "popularity",
  "category": "",
  "includeRawActors": true,
  "includeNicheReports": true
}
```

# 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 = {
    "searchTerms": [
        "lead generation",
        "linkedin scraper",
        "google maps leads"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("adamjosh/apify-store-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 = { "searchTerms": [
        "lead generation",
        "linkedin scraper",
        "google maps leads",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("adamjosh/apify-store-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 '{
  "searchTerms": [
    "lead generation",
    "linkedin scraper",
    "google maps leads"
  ]
}' |
apify call adamjosh/apify-store-opportunity-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Store Opportunity Finder: Lead Gen Edition",
        "description": "Find Apify Actor ideas by analyzing public Store demand, saturation, weak competitors, and lead-gen niche gaps.",
        "version": "0.1",
        "x-build-id": "jyafqmm4XXakeDWJB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/adamjosh~apify-store-opportunity-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-adamjosh-apify-store-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/adamjosh~apify-store-opportunity-finder/runs": {
            "post": {
                "operationId": "runs-sync-adamjosh-apify-store-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/adamjosh~apify-store-opportunity-finder/run-sync": {
            "post": {
                "operationId": "run-sync-adamjosh-apify-store-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords or lead-gen niches to analyze in Apify Store.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxActorsPerTerm": {
                        "title": "Max actors per search term",
                        "minimum": 10,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum public Store actors to fetch for each search term.",
                        "default": 200
                    },
                    "analysisMode": {
                        "title": "Analysis mode",
                        "enum": [
                            "raw",
                            "market_analysis",
                            "opportunity_report"
                        ],
                        "type": "string",
                        "description": "Use raw for Store rows only, market_analysis for grouped scoring, or opportunity_report for the strongest product output.",
                        "default": "market_analysis"
                    },
                    "sortBy": {
                        "title": "Store sorting",
                        "enum": [
                            "relevance",
                            "popularity",
                            "newest",
                            "lastUpdate"
                        ],
                        "type": "string",
                        "description": "Sort mode passed to the Apify Store API.",
                        "default": "popularity"
                    },
                    "category": {
                        "title": "Category filter",
                        "type": "string",
                        "description": "Optional Apify Store category slug.",
                        "default": ""
                    },
                    "includeRawActors": {
                        "title": "Include raw actor rows",
                        "type": "boolean",
                        "description": "Output normalized actor-level rows to the dataset.",
                        "default": true
                    },
                    "includeNicheReports": {
                        "title": "Include niche reports",
                        "type": "boolean",
                        "description": "Output grouped niche-level opportunity rows to the dataset.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
