# Apify Store Quality Radar (`signalcrawl/apify-store-quality-radar`) Actor

Find Apify Store niches and competitors with real adoption, ratings, review counts, pricing, run-quality signals, and market-gap scores.

- **URL**: https://apify.com/signalcrawl/apify-store-quality-radar.md
- **Developed by:** [SignalCrawl](https://apify.com/signalcrawl) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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 Quality Radar

Find Apify Store niches and competitors with real adoption, ratings, review counts, pricing, run-quality signals, and market-gap scores.

This Actor audits Apify Store search results and returns a ranked dataset that helps builders, agencies, and data teams decide what to build, avoid, improve, or monitor.

It is designed for people who do not want another raw catalog export. The output highlights demand, weak incumbents, pricing signals, public trust gaps, and practical buyer-workflow wedges.

The important idea: ratings and reviews are product research, not decoration. A listing with active usage but weak ratings, low review count, or confusing output is often a stronger opportunity than a niche with no competitors and no demand.

### Why Use This Actor

Apify has thousands of actors. Clicking listings manually is slow, and raw Store metadata does not directly answer the important question:

> Is this niche worth building in, and how could a new actor win?

This Actor turns public Store signals into decision-ready rows:

- Which actors have real 7-day and 30-day usage.
- Which competitors have weak ratings or thin trust signals.
- Which broad incumbents should be studied but not cloned.
- Which niches deserve deeper research before building.
- Which product angle could make a new actor more useful.

### Best For

| User | Workflow |
|---|---|
| Apify builders | Find niches with demand before coding. |
| Data product teams | Audit competitors, pricing, and usage signals. |
| Agencies | Discover actor gaps for lead-generation or automation products. |
| Indie hackers | Avoid saturated clones and find buyer-ready workflow ideas. |
| AI agents | Pull structured marketplace intelligence with stable fields. |

### What It Extracts

- Actor title, slug, URL, description, and categories.
- Total users, 30-day users, 7-day users, and bookmarks.
- Rating score and public review count.
- Review signal, review research URL, likely user pain points, and likely user likes inferred from public trust and usage signals.
- 30-day run count and success rate when exposed by the Store API.
- Pricing model, primary event, and estimated price per 1,000 results/events.
- Tags such as reviews, lead generation, AI/RAG, jobs, ads, social, ecommerce, real estate, and developer tools.
- Weakness signals such as weak rating, low trust for high demand, low success rate, thin description, or unclear pricing.
- A quality bar for what a better competing actor must prove before launch.
- Opportunity score, decision label, buyer wedge, and action note.

### Input Example

```json
{
  "searchTerms": ["review monitor", "reddit sentiment", "facebook ads library"],
  "maxActorsPerSearch": 25,
  "minUsers30Days": 1,
  "onlyWeakIncumbents": false,
  "includeGenericGiants": false
}
````

### Output Example

```json
{
  "platform": "apify_store",
  "searchTerm": "trustpilot reviews",
  "title": "Trustpilot Reviews Scraper",
  "slug": "example/trustpilot-reviews-scraper",
  "url": "https://apify.com/example/trustpilot-reviews-scraper",
  "totalUsers": 2000,
  "users30d": 120,
  "rating": 3.4,
  "reviewCount": 9,
  "reviewSignal": "active demand with visible review pain",
  "likelyUserPainPoints": [
    "runs may fail or require retries",
    "users may be unhappy with output quality or reliability",
    "review buyers likely need freshness filters, dedupe, sentiment, replies, and alert-ready notes"
  ],
  "likelyUserLikes": [
    "users are returning recently, so the workflow has recurring value",
    "users like review exports for monitoring reputation and support issues"
  ],
  "qualityBar": [
    "default input must return useful records, not an empty dataset",
    "dataset columns must be readable without opening JSON",
    "include source URL, scrapedAt, and dedupeKey on every row",
    "ship at least 10 pre-push tests plus real cloud smoke tests",
    "include rating, review text, dates, author fields, dedupe, sentiment, urgency, and reply/response signals"
  ],
  "reviewResearchUrl": "https://apify.com/example/trustpilot-reviews-scraper/reviews",
  "successRate30d": 78,
  "pricingModel": "PAY_PER_EVENT",
  "primaryPricePer1000": 2.0,
  "weaknesses": ["weak rating for visible demand", "lower 30-day run success rate"],
  "buyerWedge": "Add urgency scoring, response-gap detection, summaries, and monitor/delta mode. Compete on reliability and clearer first-run value.",
  "opportunityScore": 31.5,
  "decision": "BUILD_COUNTER_POSITIONING",
  "actionNote": "Strong candidate: demand exists and incumbent has visible weakness. Build only with a sharper buyer workflow and real smoke tests."
}
```

### Decision Labels

| Decision | Meaning |
|---|---|
| `BUILD_COUNTER_POSITIONING` | Demand exists and visible quality/trust gaps exist. Worth deeper competitor testing. |
| `RESEARCH_DEEPER` | Promising niche, but not enough evidence to build immediately. |
| `WATCHLIST` | Some signal. Monitor before building. |
| `STUDY_ONLY_GENERIC` | A broad giant. Use it as a demand map, not a clone target. |
| `LOW_SIGNAL` | Too little visible signal for a public launch. |

### How This Is Different

Many Apify Store scrapers export catalog rows. This Actor focuses on build decisions:

- It combines adoption, reviews, ratings, pricing, and run-quality signals.
- It flags weak incumbents instead of only listing popular actors.
- It turns ratings/reviews into research prompts: what users may dislike, what they probably value, and what quality bar a better actor must meet.
- It penalizes generic giants so new builders do not blindly clone saturated categories.
- It returns buyer-wedge notes that explain how a new actor could compete on output quality.

### Notes And Limitations

- Uses Apify's public Store API. No Apify token is required for normal public Store data.
- Exact actor revenue is private and cannot be guaranteed from public Store data.
- Rating and run statistics are public trust signals, not guaranteed full review-text analysis. Use `reviewResearchUrl` to manually inspect visible review pages and issues before committing to a build.
- Use this as a research filter before manual competitor testing, not as a guaranteed revenue predictor.

### Tested Coverage

The Actor is designed around public Store search responses and includes local tests for:

- Opportunity scoring.
- Weak-incumbent detection.
- Generic giant filtering.
- Pricing extraction from pay-per-event fields and tiered pricing.
- Bad input handling.

# Actor input Schema

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

Apify Store search terms to audit. Use niches, source names, buyer workflows, or competitor keywords.

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

Optional Apify Store category filter, e.g. LEAD\_GENERATION, AI, SEO\_TOOLS, JOBS, SOCIAL\_MEDIA, ECOMMERCE, AUTOMATION.

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

Apify Store sort mode.

## `maxActorsPerSearch` (type: `integer`):

Maximum actors to inspect per search term.

## `minTotalUsers` (type: `integer`):

Keep only actors with at least this many total users. Use 0 to disable.

## `minUsers30Days` (type: `integer`):

Keep only actors with at least this many 30-day users. Use 0 to disable.

## `onlyWeakIncumbents` (type: `boolean`):

Return only actors with visible demand and weaker quality/trust signals.

## `includeGenericGiants` (type: `boolean`):

Include very broad high-demand actors such as generic Google Maps, Instagram, TikTok, and LinkedIn scrapers. Disable to focus on more realistic entry points.

## Actor input object example

```json
{
  "searchTerms": [
    "review monitor",
    "reddit sentiment",
    "facebook ads library",
    "RAG crawler",
    "lead generation"
  ],
  "category": "",
  "sortBy": "popularity",
  "maxActorsPerSearch": 25,
  "minTotalUsers": 0,
  "minUsers30Days": 0,
  "onlyWeakIncumbents": false,
  "includeGenericGiants": false
}
```

# 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": [
        "review monitor",
        "reddit sentiment",
        "facebook ads library",
        "RAG crawler",
        "lead generation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalcrawl/apify-store-quality-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 = { "searchTerms": [
        "review monitor",
        "reddit sentiment",
        "facebook ads library",
        "RAG crawler",
        "lead generation",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("signalcrawl/apify-store-quality-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 '{
  "searchTerms": [
    "review monitor",
    "reddit sentiment",
    "facebook ads library",
    "RAG crawler",
    "lead generation"
  ]
}' |
apify call signalcrawl/apify-store-quality-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Store Quality Radar",
        "description": "Find Apify Store niches and competitors with real adoption, ratings, review counts, pricing, run-quality signals, and market-gap scores.",
        "version": "0.1",
        "x-build-id": "RjXN6uF9mkYWjRCgi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/signalcrawl~apify-store-quality-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-signalcrawl-apify-store-quality-radar",
                "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/signalcrawl~apify-store-quality-radar/runs": {
            "post": {
                "operationId": "runs-sync-signalcrawl-apify-store-quality-radar",
                "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/signalcrawl~apify-store-quality-radar/run-sync": {
            "post": {
                "operationId": "run-sync-signalcrawl-apify-store-quality-radar",
                "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",
                        "minItems": 1,
                        "type": "array",
                        "description": "Apify Store search terms to audit. Use niches, source names, buyer workflows, or competitor keywords.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "category": {
                        "title": "Category filter",
                        "type": "string",
                        "description": "Optional Apify Store category filter, e.g. LEAD_GENERATION, AI, SEO_TOOLS, JOBS, SOCIAL_MEDIA, ECOMMERCE, AUTOMATION.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popularity",
                            "relevance",
                            "newest",
                            "totalUsers"
                        ],
                        "type": "string",
                        "description": "Apify Store sort mode.",
                        "default": "popularity"
                    },
                    "maxActorsPerSearch": {
                        "title": "Max actors per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum actors to inspect per search term.",
                        "default": 25
                    },
                    "minTotalUsers": {
                        "title": "Min total users",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only actors with at least this many total users. Use 0 to disable.",
                        "default": 0
                    },
                    "minUsers30Days": {
                        "title": "Min 30-day users",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only actors with at least this many 30-day users. Use 0 to disable.",
                        "default": 0
                    },
                    "onlyWeakIncumbents": {
                        "title": "Only weak incumbents",
                        "type": "boolean",
                        "description": "Return only actors with visible demand and weaker quality/trust signals.",
                        "default": false
                    },
                    "includeGenericGiants": {
                        "title": "Include generic giants",
                        "type": "boolean",
                        "description": "Include very broad high-demand actors such as generic Google Maps, Instagram, TikTok, and LinkedIn scrapers. Disable to focus on more realistic entry points.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
