# Apify Stats (`agentictools/apify-store-search`) Actor

Find the best & cheapest Actors on Apify.

- **URL**: https://apify.com/agentictools/apify-store-search.md
- **Developed by:** [Ken Agland](https://apify.com/agentictools) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 Stats

Search the Apify Store and get usage stats for every matching Actor: total runs, active users, review ratings, pricing, and 30-day success rate. Rank the results by whatever you care about, such as popularity, rating, price, or recency.

This is a meta Actor. It uses the Apify Store API to find Actors and returns clean, structured stats so you can compare them and pick the best or cheapest one for a task.

### Features

- Full-text search across the whole Store (titles, names, descriptions).
- Rank by popularity, top rated, cheapest, most runs, newest, or recently updated.
- Filter by category, pricing model, minimum runs, or minimum rating.
- Per-Actor stats: total runs, total users, 7/30/90-day active users, 30-day success rate, review rating and count, bookmarks, and last run time.
- Pricing model and starting price for each Actor.
- Optional enrichment with creation and update dates, default run options, and source repo URL.
- Aggregate summary (most popular, top rated, cheapest, totals, pricing breakdown) in the run's OUTPUT.

### Example input

Most popular Instagram Actors with real traction:

```json
{ "search": "instagram", "sortBy": "popularity", "limit": 20, "minRuns": 1000 }
````

Cheapest AI Actors in the Store:

```json
{ "search": "", "category": "AI", "sortBy": "cheapest", "limit": 50 }
```

### Input

| Field | Type | Description |
|---|---|---|
| `search` | string | Full-text search term. Leave empty to browse the whole Store. |
| `category` | string | Restrict to one Store category (AI, SOCIAL\_MEDIA, ECOMMERCE, and so on). |
| `sortBy` | string | `relevance`, `popularity`, `topRated`, `cheapest`, `mostRuns`, `newest`, or `lastUpdate`. |
| `limit` | integer | How many Actors to return (auto-paginated, max 1000). |
| `offset` | integer | Skip this many Store results before collecting. |
| `minRuns` | integer | Keep only Actors run at least this many times. |
| `minRating` | number | Keep only Actors rated at least this high (0 to 5, decimals allowed). |
| `pricingModel` | string | Keep only Actors on this pricing model (`FREE`, `PAY_PER_EVENT`, and so on). |
| `enrichWithDetails` | boolean | Add dates, run options, and repo URL (one extra API call per Actor). |

#### Sorting and the search term

The Apify Store API only respects the search text when sorting by relevance. So when you combine a search term with any other order, this Actor fetches a pool of relevance matches, keeps the ones that actually mention your term, and ranks them itself. Popularity, top rated, cheapest, and most runs rank over up to 1000 matches. Newest and recently updated need one extra API call per Actor, so they are limited to 200 matches when a search term is set. For very broad searches, narrow the term to get exact rankings.

### Output

Each dataset item is one Actor:

```json
{
  "title": "Instagram Scraper",
  "name": "instagram-scraper",
  "fullName": "apify/instagram-scraper",
  "developer": "Apify",
  "username": "apify",
  "url": "https://apify.com/apify/instagram-scraper",
  "apiUrl": "https://api.apify.com/v2/acts/apify~instagram-scraper",
  "description": "Extract Instagram posts, reels, profiles, ...",
  "categories": ["SOCIAL_MEDIA"],
  "badge": null,
  "pricingModel": "PAY_PER_EVENT",
  "priceUsd": 0.0027,
  "totalRuns": 153970973,
  "totalUsers": 318106,
  "totalBuilds": 2834,
  "users7Days": 17243,
  "users30Days": 33830,
  "users90Days": 56817,
  "runs30Days": 15387349,
  "successRate30DaysPct": 99.6,
  "reviewRating": 4.74,
  "reviewCount": 477,
  "bookmarks": 4057,
  "lastRunStartedAt": "2026-07-04T14:41:17.154Z",
  "pictureUrl": "https://images.apifyusercontent.com/..."
}
```

With `enrichWithDetails` set to true (and always for the newest and lastUpdate sorts), each item also includes `createdAt`, `modifiedAt`, `gitRepoUrl`, `defaultMemoryMbytes`, `defaultTimeoutSecs`, and `seoTitle`.

#### Run summary (OUTPUT)

The run's default key-value store record `OUTPUT` holds an aggregate for the whole result set:

```json
{
  "query": { "search": "instagram", "requestedSort": "popularity" },
  "returned": 20,
  "requestedLimit": 20,
  "storeTotalForQuery": 3558,
  "scanned": 200,
  "totalRunsAcrossResults": 214813254,
  "totalUsersAcrossResults": 1106273,
  "averageReviewRating": 4.72,
  "mostPopular": "apify/instagram-scraper",
  "topRated": "apify/instagram-profile-scraper",
  "cheapest": "some/free-actor",
  "pricingBreakdown": { "PAY_PER_EVENT": 19, "FREE": 1 },
  "generatedFrom": "https://api.apify.com/v2/store"
}
```

### How it works

The Actor calls the public Apify Store API, paginates through results, dedupes them (the relevance search returns overlapping pages), applies your filters, ranks client-side when needed, and optionally fetches per-Actor details. It uses the run's `APIFY_TOKEN` automatically for higher rate limits, with no configuration needed.

### Use cases

- Pick the right Actor by comparing the best and cheapest options for a task.
- Market research: size up a niche before building your own Actor.
- Competitor tracking: snapshot runs, users, and ratings on a schedule.
- Dashboards and agents: feed live Store stats into your own tools.

MIT licensed.

# Actor input Schema

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

Full-text search term matched against Actor titles, names and descriptions (e.g. "instagram", "google maps", "pdf"). Leave empty to browse the whole Store.

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

Restrict results to a single Apify Store category.

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

How to rank the results. When a search term is set, the Apify API only respects the term with 'relevance', so every other order is applied by this Actor over a pool of relevance matches (kept on-topic). 'Cheapest' puts free Actors first; 'Top rated' ranks by review score; 'Popularity' by total users. 'Newest'/'Recently updated' fetch extra details and are limited to 200 Actors when combined with a search.

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

How many Actors to return (results are paginated automatically). Max 1000.

## `offset` (type: `integer`):

Skip this many Store results before collecting. Useful for paging through large result sets.

## `minRuns` (type: `integer`):

Only keep Actors that have been run at least this many times (client-side filter).

## `minRating` (type: `number`):

Only keep Actors with an average review rating at least this high (0-5, decimals allowed, e.g. 4.5). Actors with no reviews are treated as 0.

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

Only keep Actors using this pricing model.

## `enrichWithDetails` (type: `boolean`):

Make an extra API call per Actor to add creation/update dates, default run options and the source Git repository URL. Slower and uses more API calls.

## Actor input object example

```json
{
  "search": "google maps",
  "category": "",
  "sortBy": "relevance",
  "limit": 20,
  "offset": 0,
  "minRuns": 0,
  "minRating": 0,
  "pricingModel": "",
  "enrichWithDetails": 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 = {
    "search": "instagram"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentictools/apify-store-search").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": "instagram" }

# Run the Actor and wait for it to finish
run = client.actor("agentictools/apify-store-search").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 '{
  "search": "instagram"
}' |
apify call agentictools/apify-store-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Stats",
        "description": "Find the best & cheapest Actors on Apify.",
        "version": "0.1",
        "x-build-id": "SrpPTCfbZfwekL4Rn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentictools~apify-store-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentictools-apify-store-search",
                "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/agentictools~apify-store-search/runs": {
            "post": {
                "operationId": "runs-sync-agentictools-apify-store-search",
                "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/agentictools~apify-store-search/run-sync": {
            "post": {
                "operationId": "run-sync-agentictools-apify-store-search",
                "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": {
                    "search": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Full-text search term matched against Actor titles, names and descriptions (e.g. \"instagram\", \"google maps\", \"pdf\"). Leave empty to browse the whole Store."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "AI",
                            "AGENTS",
                            "AUTOMATION",
                            "BUSINESS",
                            "DEVELOPER_EXAMPLES",
                            "DEVELOPER_TOOLS",
                            "ECOMMERCE",
                            "EDUCATION",
                            "ENTERTAINMENT",
                            "FINANCE",
                            "GAMES",
                            "INTEGRATIONS",
                            "JOBS",
                            "LEAD_GENERATION",
                            "MARKETING",
                            "MCP_SERVERS",
                            "NEWS",
                            "OPEN_SOURCE",
                            "OTHER",
                            "REAL_ESTATE",
                            "SEO_TOOLS",
                            "SOCIAL_MEDIA",
                            "SPORTS",
                            "TRAVEL",
                            "VIDEOS",
                            "WEATHER"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single Apify Store category.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort / rank by",
                        "enum": [
                            "relevance",
                            "popularity",
                            "topRated",
                            "cheapest",
                            "mostRuns",
                            "newest",
                            "lastUpdate"
                        ],
                        "type": "string",
                        "description": "How to rank the results. When a search term is set, the Apify API only respects the term with 'relevance', so every other order is applied by this Actor over a pool of relevance matches (kept on-topic). 'Cheapest' puts free Actors first; 'Top rated' ranks by review score; 'Popularity' by total users. 'Newest'/'Recently updated' fetch extra details and are limited to 200 Actors when combined with a search.",
                        "default": "relevance"
                    },
                    "limit": {
                        "title": "Number of Actors",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many Actors to return (results are paginated automatically). Max 1000.",
                        "default": 20
                    },
                    "offset": {
                        "title": "Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip this many Store results before collecting. Useful for paging through large result sets.",
                        "default": 0
                    },
                    "minRuns": {
                        "title": "Minimum total runs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep Actors that have been run at least this many times (client-side filter).",
                        "default": 0
                    },
                    "minRating": {
                        "title": "Minimum review rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep Actors with an average review rating at least this high (0-5, decimals allowed, e.g. 4.5). Actors with no reviews are treated as 0.",
                        "default": 0
                    },
                    "pricingModel": {
                        "title": "Pricing model",
                        "enum": [
                            "",
                            "FREE",
                            "FLAT_PRICE_PER_MONTH",
                            "PRICE_PER_DATASET_ITEM",
                            "PAY_PER_EVENT"
                        ],
                        "type": "string",
                        "description": "Only keep Actors using this pricing model.",
                        "default": ""
                    },
                    "enrichWithDetails": {
                        "title": "Enrich with Actor details",
                        "type": "boolean",
                        "description": "Make an extra API call per Actor to add creation/update dates, default run options and the source Git repository URL. Slower and uses more API calls.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
