# API Marketplace Trend Radar (`wearable_monkey/api-marketplace-trend-radar`) Actor

Find hot APIs before everyone else. Scan Apify, ApyHub, APILayer, and RapidAPI public pages, track 7-day growth snapshots, and discover API product opportunities for developers, SaaS founders, agencies, and data sellers.

- **URL**: https://apify.com/wearable\_monkey/api-marketplace-trend-radar.md
- **Developed by:** [闻涛 曾](https://apify.com/wearable_monkey) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 0 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

## API Marketplace Trend Radar

Find API product opportunities before they become obvious. This Actor scans public API marketplaces, ranks hot products, saves daily snapshots, and turns marketplace signals into practical API product ideas.

### Fast trial paths

- Run a baseline scan with Apify only to get the strongest public usage signals quickly.
- Run a weekly multi-market scan across Apify, ApyHub, APILayer, and RapidAPI to spot API niches with repeated demand.
- Use the `opportunity-ideas.json` output as a build queue for new APIs, scrapers, templates, SEO pages, and agency offers.

For repeat use, schedule the Actor daily and review `top-growth-apis.json` every week. Growth comparisons become more useful after at least two saved snapshots.

### What this Actor does

- Scans API marketplaces such as Apify Store, ApyHub, APILayer, and public RapidAPI pages when available
- Ranks APIs by current demand signals such as 7-day users, 30-day users, runs, reviews, bookmarks, ratings, and marketplace rank
- Saves daily snapshots to the key-value store so later runs can calculate real 7-day growth
- Produces opportunity scores for API makers, automation agencies, SaaS builders, and data product sellers
- Generates product recommendations you can use to decide what API, scraper, automation, or data tool to build next

### Why use it?

API marketplaces move fast. Popular categories like AI, scraping, lead generation, SEO, image tools, email tools, and social data often reveal demand before traditional keyword tools catch up. This Actor gives you a repeatable market-research workflow instead of manual browsing.

### Sources

The scanner uses public marketplace data and treats failures as non-fatal:

- **Apify Store** - strongest public demand signals, including 7-day users, 30-day users, 30-day runs, reviews, ratings, and bookmarks
- **ApyHub** - structured catalog data with names, categories, providers, ratings, and pricing signals
- **APILayer** - popular marketplace cards parsed from public HTML
- **RapidAPI** - best-effort scan from public pages; results depend on page availability and protections

### Input

```json
{
  "sources": ["apify", "apyhub", "apilayer", "rapidapi"],
  "maxItemsPerSource": 100,
  "keywords": ["ai", "email", "scraper", "lead", "seo", "image", "pdf", "social"],
  "saveSnapshot": true,
  "compareDays": 7,
  "includeRapidApiBestEffort": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output

Each dataset item includes:

- `source`
- `name`
- `provider`
- `category`
- `url`
- `description`
- `rating`
- `review_count`
- `users_7d`
- `users_30d`
- `runs_30d`
- `bookmark_count`
- `pricing_model`
- `current_rank`
- `previous_rank`
- `rank_delta_7d`
- `metric_delta_7d`
- `hot_score`
- `growth_score`
- `opportunity_score`
- `confidence`
- `recommendation`

The key-value store also contains:

- `SUMMARY` - scan summary and top opportunities
- `top-hot-apis.json` - strongest current demand
- `top-growth-apis.json` - fastest growth or strongest 7-day signals
- `opportunity-ideas.json` - grouped product ideas
- `source-health.json` - source success/failure status
- `proxy_enabled` in `SUMMARY` - whether marketplace requests used the configured proxy
- `snapshot-YYYY-MM-DD.json` and `LATEST_SNAPSHOT` - growth baselines

### Proxy option

Marketplace pages can throttle or change responses. The `proxyConfiguration` input lets you run marketplace requests through Apify Proxy or custom proxies when direct requests return blocks, empty pages, or inconsistent marketplace pages. Leave proxy disabled for low-cost baseline scans and enable it for scheduled production monitoring.

### Growth tracking note

The first run creates a baseline. Real 7-day growth requires at least two snapshots, ideally from a daily schedule. Until a comparison snapshot exists, the Actor uses current 7-day demand and marketplace rank as a baseline growth signal.

### Recommended workflow

1. Run once to collect the baseline.
2. Schedule the Actor daily.
3. After 7 days, sort by `growth_score` and `opportunity_score`.
4. Pick a high-score niche and launch a focused API product with better docs, batch mode, webhooks, and clear pricing.
5. Monitor the same niche weekly to improve positioning.

### Good use cases

- Find the next API product to launch on Apify, RapidAPI, or your own site
- Track competitors across API marketplaces
- Build weekly market intelligence reports
- Discover fast-growing automation and data extraction niches
- Prioritize SEO pages and product landing pages for API tools

### Pricing transparency

This Actor is designed for pay-per-result pricing. A result corresponds to one marketplace item written to the dataset. Small scans are inexpensive; larger multi-source scans cost more because they produce more rows.

Suggested public pricing:

- Actor start: `$0.001`
- Dataset result: `$0.002` per scanned API listing

Example costs:

- 100 API listings: about `$0.20`
- 300 API listings: about `$0.60`
- 1,000 API listings: about `$2.00`

### Compliance note

This Actor does not resell third-party API access. It analyzes public marketplace information and produces market intelligence, trend rankings, and product opportunity recommendations.

# Actor input Schema

## `sources` (type: `array`):

Choose the API marketplaces to scan. Apify provides the strongest 7-day public usage signal; other sources add market coverage.

## `maxItemsPerSource` (type: `integer`):

Maximum APIs or Actors to collect from each marketplace.

## `keywords` (type: `array`):

Optional keywords that increase opportunity scoring when they appear in an API name or description.

## `saveSnapshot` (type: `boolean`):

Save the current scan into the key-value store so future runs can calculate real 7-day growth.

## `compareDays` (type: `integer`):

Number of days back to compare against when a stored snapshot exists.

## `includeRapidApiBestEffort` (type: `boolean`):

RapidAPI pages can change or be protected. Enable a non-fatal public-page scan when available.

## `proxyConfiguration` (type: `object`):

Optional proxy settings for marketplace requests. Use Apify Proxy or custom proxies when public marketplace pages throttle direct requests.

## Actor input object example

```json
{
  "sources": [
    "apify",
    "apyhub",
    "apilayer",
    "rapidapi"
  ],
  "maxItemsPerSource": 100,
  "keywords": [
    "ai",
    "email",
    "scraper",
    "lead",
    "seo",
    "image",
    "pdf",
    "social"
  ],
  "saveSnapshot": true,
  "compareDays": 7,
  "includeRapidApiBestEffort": true,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "sources": [
        "apify",
        "apyhub",
        "apilayer",
        "rapidapi"
    ],
    "keywords": [
        "ai",
        "email",
        "scraper",
        "lead",
        "seo",
        "image",
        "pdf",
        "social"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wearable_monkey/api-marketplace-trend-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 = {
    "sources": [
        "apify",
        "apyhub",
        "apilayer",
        "rapidapi",
    ],
    "keywords": [
        "ai",
        "email",
        "scraper",
        "lead",
        "seo",
        "image",
        "pdf",
        "social",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("wearable_monkey/api-marketplace-trend-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 '{
  "sources": [
    "apify",
    "apyhub",
    "apilayer",
    "rapidapi"
  ],
  "keywords": [
    "ai",
    "email",
    "scraper",
    "lead",
    "seo",
    "image",
    "pdf",
    "social"
  ]
}' |
apify call wearable_monkey/api-marketplace-trend-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "API Marketplace Trend Radar",
        "description": "Find hot APIs before everyone else. Scan Apify, ApyHub, APILayer, and RapidAPI public pages, track 7-day growth snapshots, and discover API product opportunities for developers, SaaS founders, agencies, and data sellers.",
        "version": "1.0",
        "x-build-id": "ciZDJcBc9HLlYcYdI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wearable_monkey~api-marketplace-trend-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wearable_monkey-api-marketplace-trend-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/wearable_monkey~api-marketplace-trend-radar/runs": {
            "post": {
                "operationId": "runs-sync-wearable_monkey-api-marketplace-trend-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/wearable_monkey~api-marketplace-trend-radar/run-sync": {
            "post": {
                "operationId": "run-sync-wearable_monkey-api-marketplace-trend-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",
                "properties": {
                    "sources": {
                        "title": "Marketplaces to scan",
                        "type": "array",
                        "description": "Choose the API marketplaces to scan. Apify provides the strongest 7-day public usage signal; other sources add market coverage.",
                        "default": [
                            "apify",
                            "apyhub",
                            "apilayer",
                            "rapidapi"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per source",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum APIs or Actors to collect from each marketplace.",
                        "default": 100
                    },
                    "keywords": {
                        "title": "Opportunity keywords",
                        "type": "array",
                        "description": "Optional keywords that increase opportunity scoring when they appear in an API name or description.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "saveSnapshot": {
                        "title": "Save daily snapshot",
                        "type": "boolean",
                        "description": "Save the current scan into the key-value store so future runs can calculate real 7-day growth.",
                        "default": true
                    },
                    "compareDays": {
                        "title": "Growth comparison days",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of days back to compare against when a stored snapshot exists.",
                        "default": 7
                    },
                    "includeRapidApiBestEffort": {
                        "title": "RapidAPI best-effort scan",
                        "type": "boolean",
                        "description": "RapidAPI pages can change or be protected. Enable a non-fatal public-page scan when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings for marketplace requests. Use Apify Proxy or custom proxies when public marketplace pages throttle direct requests.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```