# Apify Store Scraper: Actor Users, Runs, Prices, Trends (`actose/apify-store-explorer`) Actor

Apify Store data by keyword, category or developer: users 7/30/90 days, runs, failure rate, rating, price per 1,000, 7-day trend, plus niche summary (leader share, median price). No API key, no login. MCP-ready for AI agents. Errors and empty results are free. $0.80 per 1,000 Actors.

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

## Pricing

from $0.68 / 1,000 actor analyzeds

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 Scraper: Actor Users, Runs, Prices, Trends

**$0.80 per 1,000 Actors analyzed** · pay per result, no monthly rental · errors, empty results and the segment summary are free.

Search the **Apify Store** by keyword, category or developer and get, for every Actor: **users over 7 / 30 / 90 days, runs and failure rate over 30 days, rating and reviews, exact price (pay per event, per result or monthly), 7-day trend**, plus a **segment summary**: how many Actors compete, how much of the users the leader takes, the median price per 1,000 results.

It is the market study you need before building or pricing an Actor: find niches where demand is high, the leader is weak (low rating, high failure rate) or overpriced.

- Uses only the public Apify Store API: **no API key, no login, no proxy**, fast and stable.
- One clean JSON object per Actor, camelCase fields, export to JSON, CSV, Excel or Google Sheets.
- **MCP-ready** for Claude, Cursor, ChatGPT and AI agents, with an LLM-ready Markdown report.
- Scheduled runs: `onlyNew` delivers only Actors that appeared since the last run, and true 7-day deltas are computed from daily snapshots.

### How much does it cost?

| You analyze | You pay |
|---|---|
| 50 Actors (one niche) | $0.04 |
| 1,000 Actors (a whole category) | $0.80 |
| 10 niches × 100 Actors, every week for a month | 4 × $0.80 = $3.20 |

You are charged one `actor` event per Actor delivered in the dataset. Nothing is charged for a failed query, a query with no result, a duplicate Actor found by two keywords, or the segment summary. When your maximum cost per run is reached, the run stops cleanly and tells you how many Actors were delivered.

### Input

```json
{
  "search": "youtube transcript",
  "searches": ["google maps", "linkedin jobs"],
  "usernames": [],
  "category": "",
  "sortBy": "relevance",
  "pricingModel": "",
  "maxItems": 50,
  "minUsers30Days": 0,
  "onlyNew": false
}
```

| Field | What it does |
|---|---|
| `search` / `searches` | Keywords, exactly like the Store search box. Each keyword = one segment with its own summary. |
| `usernames` | Developers whose public Actors you want (the part after `apify.com/`). |
| `category` | Restrict to one Store category (`AI`, `LEAD_GENERATION`, `ECOMMERCE`, …). Alone, lists the whole category. |
| `sortBy` | `relevance` (what buyers see), `popularity`, `newest`, `lastUpdate`. |
| `pricingModel` | `PAY_PER_EVENT`, `PRICE_PER_DATASET_ITEM` or `FREE`. |
| `maxItems` | Max Actors per query (1–5,000). |
| `minUsers30Days` | Deliver only Actors with at least this many monthly users. |
| `onlyNew` | Deliver only Actors never delivered before for the same queries. |

### Output

One item per Actor in the dataset (table view "Overview" in the console):

```json
{
  "id": "zPumutvB61fpEsglh",
  "title": "YouTube Transcript & Subtitles Scraper API",
  "name": "YoutubeTranscripts",
  "username": "johnvc",
  "url": "https://apify.com/johnvc/youtubetranscripts",
  "categories": ["VIDEOS", "AI", "DEVELOPER_TOOLS"],
  "query": "search: youtube transcript",
  "rank": 2,
  "totalUsers": 8229,
  "users7Days": 1963,
  "users30Days": 4312,
  "users90Days": 6617,
  "totalRuns": 341769,
  "runs30Days": 191783,
  "succeededRuns30Days": 191537,
  "failedRuns30Days": 6,
  "timedOutRuns30Days": 111,
  "abortedRuns30Days": 129,
  "failureRate30Days": 0.0006,
  "successRate30Days": 0.9987,
  "runsPerUser30Days": 44.5,
  "reviewRating": 4.78,
  "reviewCount": 11,
  "bookmarkCount": 28,
  "momentum7Days": 1.95,
  "momentum30Days": 1.95,
  "users30DaysChange7Days": 512,
  "users30DaysGrowth7DaysPct": 13.5,
  "comparedToDate": "2026-10-21",
  "segmentShare30Days": 0.31,
  "pricingModel": "PAY_PER_EVENT",
  "priceUsd": 0.00275,
  "pricePer1000Usd": 2.75,
  "priceUnit": "Video Processed",
  "primaryEventName": "videoprocessed",
  "priceEvents": [
    {"name": "videoprocessed", "title": "Video Processed", "priceUsd": 0.00275, "isPrimary": true, "isOneTime": false}
  ],
  "monthlyPriceUsd": null,
  "scrapedAt": "2026-10-28T09:00:00Z"
}
```

The **segment summary** is saved (free) in the run's key-value store, record `SUMMARY` (JSON) and `SUMMARY_MD` (Markdown, ready to paste into an LLM):

```json
{
  "query": "search: youtube transcript",
  "storeTotalMatches": 1260,
  "actorsAnalyzed": 50,
  "totalUsers30Days": 13870,
  "leader": {"title": "YouTube Transcript & Subtitles Scraper API", "users30Days": 4312, "pricePer1000Usd": 2.75},
  "leaderShare30Days": 0.31,
  "top3Share30Days": 0.62,
  "herfindahlIndex": 0.17,
  "actorsWithAtLeast10Users30Days": 21,
  "medianPricePer1000Usd": 5.0,
  "medianPricePer1000UsdTop10": 4.0,
  "minPricePer1000Usd": 0.5,
  "medianReviewRating": 4.4,
  "medianFailureRate30Days": 0.03,
  "medianMomentum7Days": 1.02
}
```

#### How the metrics are computed

- `failureRate30Days` = (failed + timed-out runs) / all public runs over 30 days. Aborted runs are reported apart (often stopped by the user).
- `momentum7Days` = users of the last 7 days / weekly average of the last 30 days. Above 1 the Actor is accelerating. Available from the first run.
- `users30DaysChange7Days`, `totalUsersChange7Days`, `totalRunsChange7Days` = real change against the snapshot taken about 7 days earlier. Snapshots are stored in your named key-value store `apify-store-explorer-history`, so these fields are `null` until you have run the Actor at least once a week earlier (schedule it daily or weekly).
- `priceUsd` = price of the primary event (or of one result) for the FREE customer tier; `pricePer1000Usd` = the same × 1,000.

### Use cases

**1. A solo developer looks for a niche before building.** They compare 10 niches in one run and look for high demand with a weak leader.
Input: `{"searches": ["tiktok comments", "amazon reviews", "zillow", "indeed jobs", "google news"], "maxItems": 50, "sortBy": "popularity"}` (250 Actors, $0.20).
Output extract from `SUMMARY`: `{"query": "search: zillow", "totalUsers30Days": 2400, "leaderShare30Days": 0.58, "medianPricePer1000Usd": 3.0}` and for the leader `{"reviewRating": 3.1, "failureRate30Days": 0.12}`.
Next: a niche where the leader takes 58 % of the users with a 12 % failure rate and a 3.1 rating is an opening; they build a more reliable Actor priced below the median.

**2. A pricing manager sets the price of a new Actor.** Input: `{"search": "linkedin profile", "pricingModel": "PAY_PER_EVENT", "maxItems": 100, "minUsers30Days": 10}` ($0.08).
Output extract: `[{"title": "...", "users30Days": 950, "pricePer1000Usd": 4.0}, {"title": "...", "users30Days": 310, "pricePer1000Usd": 2.5}]`.
Next: they plot `users30Days` against `pricePer1000Usd` in Google Sheets and price just under the cheapest Actor that still has real users.

**3. A developer with a portfolio tracks their own Actors and competitors every Monday.** Input: `{"usernames": ["your-username", "competitor-username"], "maxItems": 200}` scheduled weekly ($0.16 per run for 200 Actors).
Output extract: `{"title": "...", "users30DaysChange7Days": -40, "failureRate30Days": 0.21, "momentum7Days": 0.7}`.
Next: a Make scenario posts to Slack every Actor whose `failureRate30Days` > 0.1 or whose users dropped this week, so they fix it before the reviews fall.

**4. A newsletter or agency watches new entrants.** Input: `{"category": "MCP_SERVERS", "sortBy": "newest", "maxItems": 100, "onlyNew": true}` scheduled daily.
Output: only the Actors published since yesterday, e.g. `[{"title": "...", "username": "...", "pricingModel": "PAY_PER_EVENT", "pricePer1000Usd": 1.0}]` — usually 0 to 20 per day, a few cents.
Next: the list feeds a Google Sheet and a weekly "new on the Apify Store" digest.

### API examples

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("<username>/apify-store-explorer").call(run_input={"search": "youtube transcript", "maxItems": 50})
for actor in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(actor["title"], actor["users30Days"], actor["pricePer1000Usd"], actor["failureRate30Days"])
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["segments"][0]["leaderShare30Days"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('<username>/apify-store-explorer').call({ search: 'youtube transcript', maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((a) => ({ title: a.title, users30Days: a.users30Days, price: a.pricePer1000Usd })));
```

### Integrations (Make, Zapier, n8n, Google Sheets)

- **n8n / Make:** "Run Actor" node with the input above → "Get dataset items" → filter `users30Days > 100` and `reviewRating < 4` → Google Sheets "Append row". Schedule it weekly to get a niche watchlist.
- **Zapier:** trigger "Actor run finished" → action "Google Sheets: create row" for each item.
- **Google Sheets / Excel:** export the dataset as CSV or XLSX from the console or the API (`/datasets/{id}/items?format=csv&view=overview`).
- **Webhooks:** call your own endpoint when the run finishes.

### Use with AI agents (MCP)

Add the Actor to the Apify MCP server (`https://mcp.apify.com`) in Claude, Cursor, ChatGPT or any MCP client, then ask: *"Which YouTube niches on the Apify Store have more than 1,000 monthly users and a leader rated under 4?"* The agent calls the Actor with `searches`, reads the dataset and the `SUMMARY_MD` record (compact Markdown made for LLM context windows).

### FAQ

**Do I need an Apify API token or a login for the Store?** No. The Actor reads the public Apify Store API, the same data the Store pages show.

**Why are the 7-day change fields null?** They compare with a snapshot from about 7 days ago, kept in your own account. Run the Actor on a schedule (daily or weekly) and they fill in from the second week. `momentum7Days` gives the trend from the very first run.

**Is an Actor found by two keywords charged twice?** No. It is delivered once (with the first query that found it) and charged once. Each keyword's summary still counts it.

**How fresh is the data?** Live: each run reads the Store at that moment. User and run counts are those Apify publishes (updated about daily).

**Can I get the whole Store?** Yes, run one query per category with `maxItems` up to 5,000.

**What does "failure rate" include?** Failed and timed-out public runs over 30 days. A high rate may also come from users' bad inputs; check `runsPerUser30Days` and the reviews.

### Limits

- Only public Store data: no revenue, no private Actors, no per-day history before your first run.
- The Store search covers titles, descriptions and READMEs, so a broad keyword may return loosely related Actors; use `sortBy: "popularity"` and `minUsers30Days` to focus.
- Tiered prices are reported for the FREE tier (what a new customer pays); all tiers are not listed.
- The 7-day deltas need a snapshot from 5 to 10 days earlier in your account.

# Actor input Schema

## `search` (type: `string`):

One search query, exactly like the Apify Store search box (searches title, name, description, developer and README). Example: "youtube transcript".

## `searches` (type: `array`):

Several keywords to compare several niches in one run. Each keyword gets its own segment summary. Duplicates are ignored, and an Actor found by several keywords is delivered (and charged) only once.

## `usernames` (type: `array`):

Apify usernames whose public Actors you want to list, e.g. "apify" (the part after apify.com/ in an Actor URL).

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

Restrict every query to one Store category. Used alone (with no keyword or developer), it lists the whole category.

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

Order of the Store results. "relevance" = what a buyer sees when searching; "popularity" = most used first.

## `pricingModel` (type: `string`):

Keep only Actors with this pricing model. Leave empty for all.

## `maxItems` (type: `integer`):

Maximum number of Actors analyzed per keyword / developer / category (in Store order). The segment summary is computed on these Actors.

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

Deliver only Actors with at least this many users over 30 days (the segment summary still uses all Actors). 0 = no filter.

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

For scheduled runs: deliver only Actors never delivered before for the same queries (remembered in the named key-value store "apify-store-explorer-seen"). The segment summary is always refreshed.

## Actor input object example

```json
{
  "search": "youtube transcript",
  "searches": [
    "google maps",
    "linkedin jobs"
  ],
  "sortBy": "relevance",
  "maxItems": 50,
  "minUsers30Days": 0,
  "onlyNew": false
}
```

# Actor output Schema

## `actors` (type: `string`):

No description

## `actorsJson` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `summaryMarkdown` (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 = {
    "search": "youtube transcript",
    "searches": [
        "google maps",
        "linkedin jobs"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/apify-store-explorer").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 = {
    "search": "youtube transcript",
    "searches": [
        "google maps",
        "linkedin jobs",
    ],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("actose/apify-store-explorer").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 '{
  "search": "youtube transcript",
  "searches": [
    "google maps",
    "linkedin jobs"
  ],
  "maxItems": 50
}' |
apify call actose/apify-store-explorer --silent --output-dataset

```

## MCP server setup

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

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/Q6gok6HCUX715bnrV/builds/Bsiydx9pzPhq4EL4T/openapi.json