# Apify Ideas Radar (`yummy_gelato/apify-ideas-radar`) Actor

Scans Apify Ideas and Store actors to surface build opportunities. Discover mode maps each idea to top actor matches; Search mode validates a keyword with semantic/exact matching, challenge eligibility, and competition/demand summary.

- **URL**: https://apify.com/yummy\_gelato/apify-ideas-radar.md
- **Developed by:** [Howard](https://apify.com/yummy_gelato) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 28 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## Apify Ideas Radar

**Find profitable Actor opportunities from the Apify $1M Challenge by matching community ideas with market demand data from the Apify Store.**

Apify Ideas Radar analyzes ideas from the [Apify Ideas board](https://apify.com/ideas) and matches them with existing Actors from Apify Store to help you discover untapped opportunities for the [Apify $1M Challenge](https://apify.com/challenge).

### What is Apify Ideas Radar?

Ideas Radar is a **market intelligence tool** for Apify developers. It automatically:

- **Downloads ideas** from the Apify Ideas board with customizable filters
- **Matches ideas to existing Actors** using TF-IDF semantic similarity
- **Assesses Challenge eligibility** using compound platform + scraping detection
- **Identifies market signals** like rising demand, painful unmet needs, and proven traction
- **Validates niches** with keyword search and competition analysis
- **Outputs actionable data** with match evidence and opportunity scoring

Whether you're exploring the entire ideas board or validating a specific niche, Ideas Radar gives you **data-driven insights** to make better decisions about what to build.

### Why use Apify Ideas Radar?

#### Find Opportunities Faster

Manual research takes hours. Ideas Radar processes hundreds of ideas and actors in minutes, surfacing opportunities you might have missed.

#### Make Data-Driven Decisions

Instead of guessing, see **actual market signals**:

- How many people requested this idea?
- Are there existing Actors solving similar problems?
- What's the competition level?
- Is there rising demand or proven traction?

#### Focus on Challenge-Eligible Ideas

Built-in eligibility assessment filters out ideas that mention restricted platforms (YouTube, LinkedIn, Instagram, etc.) combined with scraping keywords, so you focus on Challenge-eligible opportunities.

#### Validate Your Niche

Use Search mode to instantly check if your idea has demand and assess the competitive landscape before investing time in development.

### How to use Apify Ideas Radar

#### Quick Start: Discover Mode

1. **Run the Actor** with default settings (no configuration needed)
2. **Review results** in the dataset - each idea includes eligibility status and top 3 evidence matches
3. **Sort by fit tags** to find ideas with market signals like `rising`, `painful_demand`, or `proven_demand`
4. **Pick an opportunity** and start building!

**Example Input (Discover Mode):**

```json
{
  "mode": "discover",
  "challengeEligibleOnly": true
}
```

**What you get:** A dataset of Challenge-eligible ideas, each matched with evidence Actors that prove demand exists.

#### Validate a Niche: Search Mode

Have a specific idea or keyword? Use Search mode to validate it:

1. **Set mode** to `search`
2. **Enter your keyword** (e.g., "shopify", "pricing monitoring", "pdf parser")
3. **Choose search method**:
   - `semantic` - finds related concepts using TF-IDF (recommended)
   - `exact` - finds literal keyword matches
4. **Review the summary** to see competition, demand signals, and opportunity assessment

**Example Input (Search Mode):**

```json
{
  "mode": "search",
  "keyword": "pricing page monitoring",
  "searchMethod": "semantic"
}
```

**What you get:** A single result with matching ideas, actors, and a competition summary that tells you if the niche is worth pursuing.

### How much does Apify Ideas Radar cost?

Ideas Radar uses **pay-per-event** pricing for transparent, predictable costs.

#### Pricing Breakdown

| Event | Price | When Charged |
|-------|-------|--------------|
| **Actor Start** | $0.00005 | Once per run (Apify synthetic event) |
| **Idea Found** (Search mode) | **$0.002** | Per eligible idea in search results |
| **Dataset Item** (Discover mode) | **$0.002** | Per eligible idea matched |

#### Example Costs

**Discover Mode:**

- 50 ideas = **$0.10**
- 100 ideas = **$0.20**
- 200 ideas = **$0.40**

**Search Mode:**

- 10 matching ideas = **$0.02**
- 25 matching ideas = **$0.05**
- 50 matching ideas = **$0.10**

#### Free Tier

On Apify's **free plan**, you get $5 of free credits monthly - enough for **2,500 ideas** analyzed!

#### Why pay-per-event?

You only pay for **results you receive**. If a search returns 0 ideas, you don't pay. If you filter to Challenge-eligible ideas only, you're not charged for ideas that were filtered out.

### What data can Apify Ideas Radar extract?

#### Discover Mode Output

Each idea includes:

| Field | Description |
|-------|-------------|
| `title` | Idea title from Apify Ideas board |
| `url` | Direct link to the idea |
| `eligible_for_challenge` | Boolean - is this Challenge-eligible? |
| `ineligible_reason` | Why the idea was marked ineligible (if applicable) |
| `evidence_actors` | Array of top 3 matching Actors with similarity scores |
| `fit_tags` | Market signals (e.g., `rising`, `painful_demand`, `proven_demand`) |

#### Search Mode Output

| Field | Description |
|-------|-------------|
| `keyword` | Your search term |
| `searchMethod` | `semantic` or `exact` |
| `ideas` | Array of matching ideas with eligibility assessment |
| `actors` | Array of matching Actors with usage stats |
| `summary.competition` | `low`, `medium`, or `high` (based on actor count) |
| `summary.demand_signal` | `weak`, `moderate`, or `strong` (based on fit tags) |
| `summary.opportunity_assessment` | Plain-English assessment combining all factors |

### Input

Click on the **Input** tab to configure these options:

#### Mode Selection

- **Discover** (default): Scans all ideas and matches each to Store Actors
- **Search**: Validates a specific keyword or niche

#### Search Options (Search mode only)

- **Keyword**: Your search term (e.g., "shopify", "email parser")
- **Search Method**: `semantic` (TF-IDF, finds related concepts) or `exact` (literal match)

#### Filtering Options

- **Ideas Status**: `To Develop` (default) or `All`
- **Idea Categories**: Optional allowlist (e.g., \["SEO Tools", "Lead Generation"])
- **Challenge Eligible Only**: Filter to only Challenge-eligible ideas (default: `true`)
- **Idea Keyword Excludes**: Custom keywords that mark ideas as ineligible

#### Actor Pool Configuration

- **Pricing Model**: Filter actors by pricing (`FREE`, `PAY_PER_EVENT`, etc.)
- **Exclude Actor Keywords**: Remove actors containing specific keywords
- **Fit Types**: Which market signals to detect (default: all four types)

#### Advanced Matching

- **Number of Top Matches**: How many actors to keep per idea (default: 3)
- **Minimum Similarity**: Threshold for matching (0.0-1.0, default: 0.18)

### Output

#### Discover Mode Example

```json
{
  "type": "idea",
  "title": "Weather API integration tool",
  "url": "https://apify.com/ideas/weather-api-integration",
  "eligible_for_challenge": true,
  "ineligible_reason": null,
  "evidence_actors": [
    {
      "actor_title": "OpenWeather API Connector",
      "actor_url": "https://apify.com/username/weather-connector",
      "similarity": 0.76,
      "fit_tags": ["rising", "high_intent_low_usage"]
    },
    {
      "actor_title": "Weather Data Scraper",
      "actor_url": "https://apify.com/username/weather-scraper",
      "similarity": 0.68,
      "fit_tags": ["painful_demand"]
    }
  ]
}
```

#### Search Mode Example

```json
{
  "type": "search_result",
  "keyword": "shopify",
  "searchMethod": "semantic",
  "ideas": [
    {
      "title": "Shopify product analyzer",
      "url": "https://apify.com/ideas/shopify-analyzer",
      "similarity": 0.89,
      "eligible_for_challenge": true
    }
  ],
  "actors": [
    {
      "title": "Shopify Scraper",
      "url": "https://apify.com/username/shopify-scraper",
      "similarity": 0.92,
      "users30": 450,
      "fit_tags": ["proven_demand", "rising"]
    }
  ],
  "summary": {
    "idea_count": 3,
    "actor_count": 12,
    "competition": "high",
    "demand_signal": "strong",
    "opportunity_assessment": "High competition but proven demand. Look for underserved niches within Shopify ecosystem."
  }
}
```

You can download the dataset in **JSON**, **CSV**, **Excel**, or **HTML** format from the Output tab.

### Challenge Eligibility Rules

Ideas are automatically assessed for Challenge eligibility using **compound detection**:

#### Ineligible Ideas

An idea is marked ineligible when it mentions **BOTH**:

1. **A restricted platform**: YouTube, LinkedIn, Instagram, Facebook, TikTok, X/Twitter, Apollo.io, Amazon, Google Maps, Google Search, Google Trends
2. **A scraping keyword**: scrape, scraper, scraping, crawler, extract, extractor, harvest, data mining, collect data, etc.

#### Examples

✅ **Eligible:**

- "YouTube tutorial generator" (platform without scraping)
- "Generic web scraper" (scraping without restricted platform)
- "Shopify product tracker" (e-commerce platform, not in restricted list)

❌ **Ineligible:**

- "LinkedIn data scraper" (LinkedIn + scraping keyword)
- "Instagram post extractor" (Instagram + extraction keyword)
- "YouTube video harvester" (YouTube + harvesting keyword)

#### Custom Exclusions

Use `idea_keyword_excludes` to add your own exclusion rules. Any keyword match immediately marks the idea as ineligible, regardless of platform.

### Understanding Fit Tags

Fit tags are **market signals** computed from Actor usage data:

| Tag | What it means | Thresholds |
|-----|--------------|------------|
| `rising` | Growing rapidly (users7/users90 > 0.3, users30 > 10) | Hot new niche |
| `painful_demand` | Low satisfaction but high usage (rating < 4.0, users90 > 25, reviews > 3) | Opportunity to build better |
| `proven_demand` | High satisfaction + strong usage (rating ≥ 4.0, users90 > 100, reviews > 5) | Validated market |
| `high_intent_low_usage` | High bookmarks but few users (bookmarks > 100, users90 < 50) | Interested but underserved |

**Pro tip:** Filter for `painful_demand` or `high_intent_low_usage` to find opportunities where you can build a better solution!

### FAQ

#### Can I use this for non-Challenge ideas?

Yes! While optimized for the Apify $1M Challenge, Ideas Radar is useful for any Apify Actor development. Set `challengeEligibleOnly: false` to see all ideas regardless of eligibility.

#### How accurate is the similarity matching?

Ideas Radar uses TF-IDF (Term Frequency-Inverse Document Frequency), the same algorithm used in search engines. Similarity scores above 0.6 are strong matches; above 0.8 are very strong matches.

#### What if I want to search multiple keywords?

Run the Actor once per keyword (Search mode handles one keyword at a time). You can schedule multiple runs or use the API to batch searches.

#### Can I customize the eligibility rules?

Yes! Use `idea_keyword_excludes` to add custom exclusion keywords. For example, adding `["gambling", "crypto"]` will mark any idea mentioning those keywords as ineligible.

#### How often is the Apify Ideas data updated?

The Actor fetches ideas in real-time from the [Apify Ideas CSV endpoint](https://apify.com/ideas). You'll always get the latest ideas available.

#### How do I integrate this with my workflow?

Use Apify's **Scheduling** to run weekly and catch new ideas, **Webhooks** to trigger actions when new opportunities appear, or the **API** to integrate with your own tools.

#### Is it legal to scrape Apify Ideas?

Yes! The Apify Ideas board is public data provided by Apify specifically for this purpose. This Actor uses Apify's official CSV endpoint.

### Tips for Best Results

#### Finding Hidden Gems

1. **Use Discover mode with `challengeEligibleOnly: true`** to get a curated list
2. **Sort by fit tags** in the dataset view - look for `painful_demand` (build better) or `high_intent_low_usage` (underserved)
3. **Check ideas with few evidence matches** - these might be underserved niches!

#### Validating Your Idea

1. **Use Search mode with semantic matching** for your core keyword
2. **Check the competition level** in the summary
3. **Look at demand\_signal** - `weak` might mean unproven, `strong` means validated
4. **Review evidence actors** - are they highly rated? Recent? Actively used?

#### Reducing Costs

- Use `max_ideas` to limit processing (e.g., `max_ideas: 100` for quick scans)
- Set `challengeEligibleOnly: true` to avoid paying for ineligible ideas
- Use `idea_categories` to focus on specific categories
- In Search mode, use `exact` matching for precise searches (fewer results = lower cost)

### Support

- 🐛 **Found a bug?** [Open an issue](https://github.com/howsun7/apify-ideas-radar/issues)
- 💡 **Feature request?** [Start a discussion](https://github.com/howsun7/apify-ideas-radar/discussions)
- ❓ **Questions?** Check the [Issues tab](https://github.com/howsun7/apify-ideas-radar/issues) first

### Running locally

Clone the repository and run:

```bash
apify run
```

Run tests:

```bash
uv run pytest
```

### Related Resources

- [Apify Ideas Board](https://apify.com/ideas) - Submit and vote on Actor ideas
- [Apify $1M Challenge](https://apify.com/challenge) - Learn about the Challenge
- [Apify Actor Development](https://docs.apify.com/platform/actors) - Build your own Actors
- [Pay-Per-Event Pricing](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) - Monetize your Actors

***

**Built with ❤️ for the Apify developer community**

# Actor input Schema

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

Discover finds opportunities across all ideas. Search validates a specific keyword.

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

Keyword or phrase to search for (e.g., 'shopify', 'pricing page monitoring'). Required for search mode.

## `searchMethod` (type: `string`):

Semantic finds related concepts using TF-IDF. Exact finds literal keyword matches.

## `ideas_status` (type: `string`):

Filter ideas by development status. 'To Develop' shows ideas awaiting development, 'All' shows all ideas.

## `max_ideas` (type: `integer`):

Limit the number of ideas to process (1-10000). Leave empty for no limit.

## `idea_categories` (type: `array`):

Filter ideas to only these categories. Empty = all categories. Ideas without categories are always included.

## `max_actors` (type: `integer`):

Limit the number of actors to fetch from Store API (1-10000). Leave empty for no limit.

## `exclude_actor_keywords` (type: `array`):

Case-insensitive substring filters for actors. Any actor whose name/title/description contains any keyword is removed from the evidence pool. Leave empty to disable. This does not affect idea risk detection.

## `pricing_model` (type: `string`):

Filter store actors by pricing model before matching to ideas. Leave empty to include all pricing models. Challenge-eligible options are FREE and PAY\_PER\_EVENT; PRICE\_PER\_DATASET\_ITEM (PPR) and FLAT\_PRICE\_PER\_MONTH (Rental) are not Challenge-eligible.

## `challenge_eligible_only` (type: `boolean`):

Filter out ideas that are ineligible for the Apify $1M Challenge. Ineligible ideas mention a restricted platform (YouTube, LinkedIn, etc.) AND a scraping-related keyword. Custom exclusions via 'Idea Keyword Excludes' also mark ideas as ineligible.

## `idea_keyword_excludes` (type: `array`):

Additional keywords that mark ideas as ineligible (case-insensitive substring matching). Ideas matching any keyword will have eligible\_for\_challenge=false.

## `fit_types` (type: `array`):

Market signal types to detect. Select which fit-types to include in output.

## `fit_threshold_overrides` (type: `object`):

Optional: Override default thresholds per fit-type. Provide an object keyed by fit type (painful\_demand, high\_intent\_low\_usage, rising, proven\_demand) with only the numeric thresholds you want to change. Supported keys: minUsers30, maxRating, minReviews, minBookmarks, maxUsers30, minUsers7Ratio, minUsers90, minRating. Example: {"painful\_demand": {"minUsers30": 500, "maxRating": 3.5}, "rising": {"minUsers7Ratio": 0.6}}. Leave empty to keep defaults: painful\_demand (minUsers30=100, maxRating=4.0, minReviews=5); high\_intent\_low\_usage (minBookmarks=50, maxUsers30=100); rising (minUsers30=20, minUsers7Ratio=0.35); proven\_demand (minUsers90=200, minRating=4.0, minReviews=10).

## `num_top_similar` (type: `integer`):

Number of most similar actors to include as evidence for each idea (1-10).

## `min_similarity` (type: `string`):

Minimum cosine similarity threshold for including actor matches (0.0-1.0). Lower values include more matches.

## Actor input object example

```json
{
  "mode": "discover",
  "searchMethod": "semantic",
  "ideas_status": "toDevelop",
  "idea_categories": [],
  "challenge_eligible_only": true,
  "idea_keyword_excludes": [],
  "fit_types": [
    "painful_demand",
    "high_intent_low_usage",
    "rising",
    "proven_demand"
  ],
  "num_top_similar": 3,
  "min_similarity": "0.18"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("yummy_gelato/apify-ideas-radar").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("yummy_gelato/apify-ideas-radar").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 '{}' |
apify call yummy_gelato/apify-ideas-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lYJCgGATRl7qnL7uh/builds/9JiEkMQGNedNxtGqg/openapi.json