# Apify Store Trends API - Niche Finder, Rising Actors (`martin10291/apify-store-trends-niche-finder`) Actor

Apify Store trends API backed by a daily archive of every public actor (users 7/30/90 days, total users, runs, success rate, rating, price), archived daily since 2026-11-03. Three modes: rising actors sorted by momentum or user growth, niche finder with a verdict per keyword (open, crowded, thin, co

- **URL**: https://apify.com/martin10291/apify-store-trends-niche-finder.md
- **Developed by:** [Martin Petrov](https://apify.com/martin10291) (community)
- **Categories:** Developer tools, AI, Automation
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Apify Store Trends API - Niche Finder, Rising Actors

**Which Apify niches are rising and where is there room for a new actor? The Store only shows today's numbers.** This actor answers from our own daily archive of the Apify Store: every public actor is snapshotted once a day (users in the last 7, 30 and 90 days, total users, runs, success rate, rating, price). You get rising actors, a verdict per niche keyword, and the daily history of any actor, as clean JSON.

No scraping on your side, no proxies, no login. One call, one JSON row per actor or keyword.

### Who needs it

- **Actor developers**: find a niche with real demand and a weak top 3 before you build.
- **Agencies and analysts**: track which categories grow and which actors lose users.
- **AI agents**: ask "is there room for a new TikTok or PDF actor?" and get a verdict, not a page to parse.

### Three modes

| Mode | What you get |
|---|---|
| `rising` (default) | Actors sorted by `momentum` (7-day users scaled to 30 days and divided by the 30-day users, above 1 means growing faster this week), by user change, or by size. Filter by keyword, category and minimum users. |
| `niche` | One row per search term: actors in the niche, active actors, clone actors, total users, leader, top-3 share, a `verdict` (open, crowded, thin, contested, empty) and the top actors. |
| `history` | One row per actor: current numbers plus daily rows (users 7/30/90, total users, runs, rating, reviews, price). |

### How to use it (step by step)

1. Click **Try for free**.
2. Pick a **Mode**. The default (`rising`, minimum 10 monthly users, 50 results) works immediately.
3. For `niche` enter **Search terms**; for `history` enter **Actors** as `username/name`.
4. Click **Start** and download JSON, CSV or Excel, or call it by API.

### API example (copy and paste)

Replace `MY_APIFY_TOKEN` with your token from Apify Console, Settings, Integrations.

```bash
curl -s -X POST "https://api.apify.com/v2/acts/martin10291~apify-store-trends-niche-finder/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"niche","searchTerms":["tiktok","company register","pdf"]}'
```

Rising actors in one category:

```bash
curl -s -X POST "https://api.apify.com/v2/acts/martin10291~apify-store-trends-niche-finder/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"rising","category":"AI","minUsers30":10,"sortBy":"momentum","limit":50}'
```

### Use it from AI agents (MCP)

Add it to the [Apify MCP server](https://mcp.apify.com) for Claude, Cursor or any MCP-capable agent:

```
https://mcp.apify.com?tools=martin10291/apify-store-trends-niche-finder
```

Then ask: "Which rising Apify actors in ECOMMERCE have fewer than 3 competitors?" or "Is the niche 'company register' open?". The output is flat, documented JSON.

### What makes this one different

- **Daily history.** Other Store tools show a live snapshot. This archive keeps one snapshot per day, so you can see growth over time and ask for actor history. Our archive started on **2026-11-03** and grows every day. Past days cannot be backfilled by anyone starting later.
- **Niche verdict.** Not just a list: how many actors, how many are active, how many are clones, how concentrated the top 3 are, and whether the niche looks open or crowded.
- **Momentum.** `users7 * 30 / 7 / users30`. It works from day 1, because the Store itself reports 7, 30 and 90 day users.

Honest limits: history begins on 2026-11-03, so day-over-day deltas (`users30Delta`, `users30DeltaPct`) are small at first and get more meaningful each day. Every row carries `comparedWith`, `firstSeenDay`, `archiveFrom` and `archiveSnapshots` so you can see how much history stands behind the numbers. Actors that joined the archive after the comparison day are compared with their own first snapshot, so every row has a delta (`comparedWith` shows the day used). Data comes from public Store statistics only.

### Input

| Field | Default | Description |
|---|---|---|
| `mode` | rising | `rising`, `niche` or `history` |
| `search` | empty | Rising: keyword filter (one or more) |
| `category` | empty | Rising: Store category such as AI, ECOMMERCE, SOCIAL_MEDIA |
| `minUsers30` | 10 | Rising: ignore actors with fewer monthly users |
| `sortBy` | momentum | Rising: momentum, users30Delta, users30DeltaPct, users30 |
| `lookbackDays` | 30 | Rising: compare with the snapshot about this many days ago |
| `searchTerms` | tiktok, company register, pdf (prefill) | Niche: required keywords |
| `actors` | empty | History: required, `username/name` |
| `limit` | 50 | Max rows (1 to 1000) |
| `onlyNew` | false | Rising: output only actors not output before for this Monitor ID |
| `monitorId` | default | Separate memory per watch |

### Output example (niche mode, shortened)

```json
{
  "searchTerm": "tiktok",
  "actors": 438,
  "activeActors": 318,
  "cloneActors": 77,
  "users30Sum": 79522,
  "users30SumThen": 77764,
  "users30SumDeltaPct": 2.3,
  "leader": "clockworks/tiktok-scraper",
  "leaderUsers30": 33580,
  "leaderRating": 4.75,
  "leaderPriceUsd": 0.0037,
  "top3SharePct": 61.2,
  "verdict": "crowded: leader above 150 monthly users",
  "comparedWith": "2026-11-03",
  "day": "2026-11-04",
  "topActors": ["... one object per actor, same fields as rising mode ..."]
}
```

Rising mode row (shortened): `{"actor": "corent1robert/google-play-developer-contacts", "users7": 136, "users30": 136, "users90": 140, "usersTotal": 151, "momentum": 4.29, "runs30": 774, "successRate30": 100.0, "pricingModel": "PAY_PER_EVENT", "priceUsd": 0.005, "users30Delta": 0, "comparedWith": "2026-11-03", "archiveFrom": "2026-11-03", "archiveSnapshots": 2}`

### Monitoring

In rising mode turn on **Only new actors** and set a **Monitor ID**. Only actors not output before for that ID are returned, for example "new actors in AI with momentum above all others since last week". The first run outputs everything. Ignored in niche and history modes.

### Pricing

Pay per result: **$3 per 1,000 results**. One result is one dataset row (an actor in rising mode, a keyword in niche mode, an actor in history mode). A history request for an unknown actor is not saved and not charged. Failed runs (for example a server error) save nothing.

### FAQ

**Where does the data come from?** From our own daily snapshots of the public Apify Store, kept on our server. The actor is a thin client over that archive.

**How far back does it go?** To 2026-11-03. See `archiveFrom` and `archiveSnapshots` in each row.

**What does a verdict mean?** `open` means a small number of active actors and a weak leader, `crowded` a strong leader, `thin` little demand, `contested` many similar actors, `empty` no actor found. It is a guide, not a guarantee; check the top actors yourself.

**Why are deltas 0 right now?** The archive is young. Deltas compare today with the oldest snapshot within your lookback window and grow more meaningful every day.

**Does it use proxies or log in anywhere?** No. It calls one API with an honest User-Agent (`ApifyStoreTrends/1.0`).

**A run failed. Why?** See the `RUN_SUMMARY` record in the key-value store: the `lastError` field says what happened (bad input, server error after 3 retries).

# Actor input Schema

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

rising = actors whose usage is growing (default). niche = for each search term, how crowded the Store is and whether there is room for a new actor. history = daily usage history of specific actors.

## `search` (type: `array`):

Rising mode only. Optional keywords; only actors whose name, title or category match are returned (all words of one keyword must match; any keyword can match). Leave empty for the whole Store.

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

Rising mode only. Optional Apify Store category in capitals, for example AI, ECOMMERCE, SOCIAL_MEDIA, LEAD_GENERATION, DEVELOPER_TOOLS. Empty means all categories.

## `minUsers30` (type: `integer`):

Rising mode only. Ignore actors with fewer monthly users than this. Higher values remove noise from brand-new or tiny actors.

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

Rising mode only. momentum = how much faster the last 7 days grow than the 30-day average (above 1 means accelerating). users30Delta and users30DeltaPct = change in monthly users since the comparison day. users30 = biggest actors first.

## `lookbackDays` (type: `integer`):

Rising mode only. Compare today with the archive snapshot about this many days ago. If the archive is younger, the oldest snapshot is used. Actors added to the archive later are compared with their own first snapshot (see comparedWith and firstSeenDay in each row).

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

Niche mode only, required there. Keywords describing a possible actor idea, for example tiktok, company register, pdf. You get one verdict row per term.

## `actors` (type: `array`):

History mode only, required there. Actor IDs in the form username/name, for example apify/website-content-crawler or clockworks/tiktok-scraper.

## `limit` (type: `integer`):

Maximum number of rows returned (1 to 1000). In niche mode it also limits how many top actors are listed per term.

## `onlyNew` (type: `boolean`):

For monitoring in rising mode: output only actors not output before for this Monitor ID. The first run outputs everything. Ignored in niche and history modes.

## `monitorId` (type: `string`):

Separate memory for each watch (used with only-new mode). Use a different ID per keyword, category or filter combination.

## Actor input object example

```json
{
  "mode": "rising",
  "search": [],
  "category": "",
  "minUsers30": 10,
  "sortBy": "momentum",
  "lookbackDays": 30,
  "searchTerms": [
    "tiktok",
    "company register",
    "pdf"
  ],
  "actors": [
    "apify/website-content-crawler"
  ],
  "limit": 50,
  "onlyNew": false,
  "monitorId": "default"
}
```

# Actor output Schema

## `results` (type: `string`):

Rising mode: one row per Apify Store actor. Niche mode: one row per search term with verdict. History mode: one row per actor with daily history.

# 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": [
        "tiktok",
        "company register",
        "pdf"
    ],
    "actors": [
        "apify/website-content-crawler"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("martin10291/apify-store-trends-niche-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": [
        "tiktok",
        "company register",
        "pdf",
    ],
    "actors": ["apify/website-content-crawler"],
}

# Run the Actor and wait for it to finish
run = client.actor("martin10291/apify-store-trends-niche-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "tiktok",
    "company register",
    "pdf"
  ],
  "actors": [
    "apify/website-content-crawler"
  ]
}' |
apify call martin10291/apify-store-trends-niche-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,martin10291/apify-store-trends-niche-finder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bXE9hOMbwjv3nOO6F/builds/Zd6NJztQrTazLhLHC/openapi.json