# Apify Public Actor Scraper (`zerobreak/apify-public-actor-scraper`) Actor

Apify public actor scraper that pulls metadata from every public actor in the Apify marketplace including names, authors, run stats, and pricing, so SEO researchers and developers can map the ecosystem fast.

- **URL**: https://apify.com/zerobreak/apify-public-actor-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 0 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/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Public Actor Scraper: Search and Extract Metadata from the Apify Marketplace

Apify public actor scraper pulls metadata from any public actor listed on the Apify marketplace. Give it a search term or pick a category, and it returns actor names, authors, descriptions, run counts, pricing models, and direct marketplace URLs as a structured dataset.

No API key needed. The actor reads the public Apify Store API and pages through results automatically.

### Use cases

- **SEO research**: find all actors in a category to see what automation tools already exist in your niche
- **Marketplace auditing**: track how many actors exist per category or pricing model
- **Tool discovery**: check what scrapers are already built before starting your own
- **Competitive intelligence**: monitor new actors appearing in specific categories over time
- **Data journalism**: analyze growth and activity patterns across the Apify ecosystem

### What data does this actor extract?

Each actor record includes its ID, slug, author username, display title, short description, category tags, total run count, last run timestamp, pricing model, price per unit (if paid), and the full marketplace URL.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | (empty) | Keyword to search actor names and descriptions. Leave empty to collect all actors. |
| `category` | string | All categories | Filter by marketplace category: AI, SEO tools, E-commerce, and more. |
| `sortBy` | string | Popularity | Sort order: Popularity (most runs first), Latest (newest first), or Alphabetical. |
| `maxItems` | integer | 100 | Max actors to collect per run. Hard cap at 1000. |
| `timeoutSecs` | integer | 300 | Overall run timeout in seconds. |
| `requestTimeoutSecs` | integer | 30 | Per-request API timeout in seconds. |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location for requests. Supports Datacenter, Residential, Special, and custom proxies. Optional. |

#### Example input

```json
{
    "searchQuery": "web scraper",
    "category": "SEO_TOOLS",
    "sortBy": "POPULARITY",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output

The actor stores results in a dataset. Each entry looks like this:

```json
{
    "actorId": "TpMnJNE9Ypfq5J3KP",
    "actorSlug": "web-scraper",
    "username": "apify",
    "actorFullName": "apify/web-scraper",
    "actorTitle": "Web Scraper",
    "actorDescription": "Crawls websites and extracts data using a browser.",
    "categories": ["DEVELOPER_TOOLS"],
    "totalRuns": 4500000,
    "lastRunAt": "2024-12-01T10:23:00.000Z",
    "pricingModel": "FREE",
    "pricePerUnitUsd": null,
    "url": "https://apify.com/apify/web-scraper",
    "scrapedAt": "2024-12-15T08:00:00.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `actorId` | string | Unique Apify platform identifier. |
| `actorSlug` | string | URL-friendly kebab-case actor name. |
| `username` | string | Author's Apify username. |
| `actorFullName` | string | Full identifier in `username/actor-slug` format. |
| `actorTitle` | string | Display title shown on the marketplace. |
| `actorDescription` | string | Short description of what the actor does. |
| `categories` | array | Marketplace category tags. |
| `totalRuns` | integer | Total number of times the actor has been run. |
| `lastRunAt` | string | ISO 8601 timestamp of the most recent run. |
| `pricingModel` | string | FREE, FLAT\_PRICE\_PER\_MONTH, or PAY\_PER\_RESULT. |
| `pricePerUnitUsd` | number | Price per unit in USD for paid actors. Null for free actors. |
| `url` | string | Direct link to the actor's marketplace page. |
| `scrapedAt` | string | ISO 8601 timestamp of when this record was collected. |

### How it works

1. Reads your search query, category filter, and sort preference from the input.
2. Calls the Apify Store API and pages through results in batches.
3. Extracts actor metadata from each page and pushes records to the dataset.
4. Stops when it hits your `maxItems` limit or runs out of results.

### FAQ

**Can I collect all public actors on Apify?**
Yes. Leave `searchQuery` and `category` blank and set `maxItems` to 1000. The actor pages through all available results automatically.

**Does this need an Apify API key?**
No. It uses the public Apify Store API, which requires no authentication.

**What categories are available?**
AI, Automation, Developer tools, E-commerce, Entertainment, Finance, Jobs, Marketing, News, SEO tools, Social media, and Travel.

**How many actors can I collect per run?**
Up to 1000 per run. Run it multiple times with different filters to build a larger dataset across categories.

**Can I run it on a schedule to track new actors?**
Yes. Set up a scheduled run in your Apify account and the actor will collect fresh marketplace data on whatever cadence you need.

### Integrations

Connect Apify Public Actor Scraper with other tools using [Apify integrations](https://apify.com/integrations). Export results to Google Sheets, Airtable, Slack, Make, Zapier, or Airbyte. Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger downstream actions whenever a scrape finishes.

Apify public actor scraper is the fastest way to get a complete, structured view of what automation tools exist on the Apify marketplace, without clicking through hundreds of pages by hand.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for in actor names and descriptions. Leave empty to scrape all public actors.

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

Filter actors by marketplace category. Leave empty to return actors from all categories.

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

How to sort the results. Popularity returns the most-used actors first; Latest returns the newest actors first.

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

Maximum number of actors to scrape. Increase for a fuller picture of the marketplace.

## `timeoutSecs` (type: `integer`):

Maximum total run time in seconds before the actor stops.

## `requestTimeoutSecs` (type: `integer`):

Maximum time in seconds to wait for each API response.

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

Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.

## Actor input object example

```json
{
  "searchQuery": "web scraper",
  "category": "",
  "sortBy": "popularity",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "web scraper",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/apify-public-actor-scraper").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 = {
    "searchQuery": "web scraper",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/apify-public-actor-scraper").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 '{
  "searchQuery": "web scraper",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zerobreak/apify-public-actor-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/q6gXBTE4eIIVq3qoy/builds/OrbFZ7qGz3LFiaxe3/openapi.json