# Replicate AI Model Explore Scraper (`crawlerbros/replicate-ai-explore-scraper`) Actor

Scrape Replicate's public model catalog (replicate.com/explore) - browse trending AI models, filter by one of 39 task collections (text-to-image, LLMs, video, audio), browse a creator's models, or look up models by owner/name. Extracts run counts, descriptions, cover images, versions.

- **URL**: https://apify.com/crawlerbros/replicate-ai-explore-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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

## Replicate AI Model Explore Scraper

Scrape **Replicate's** public model catalog (replicate.com/explore) — the directory of AI models runnable via API for image generation, LLMs, video, speech, and more. Browse trending & featured models, filter by one of 39 task collections (text-to-image, LLMs, video, audio, and more), browse a creator's full model list, search by keyword, or look up specific models by `owner/model-name`. Extracts exact run counts, descriptions, cover images, published per-unit pricing, and latest version IDs straight from each model's own page. HTTP-only, no login, no API key, no proxy required.

### What this actor does

- **Five modes:** `trending`, `byCollection`, `byOwner`, `byModelIds`, `search`
- **Live per-model detail lookup:** every record is built from that model's own Replicate page — exact run count, official-model flag, hardware, pricing, and latest version are always current
- **Finite collection enum:** 39 official Replicate task collections (text-to-image, text-to-video, LLMs, speech-to-text, upscaling, background removal, and more)
- **Filters:** minimum run count, official-models-only
- **Published pricing:** per-unit price (per image, per second of video, per input/output token, etc.), including resolution/mode-gated tiers when a model has more than one
- Empty fields are omitted from every record

### Output per model

- `modelId` — `owner/model-name` (e.g. `black-forest-labs/flux-dev`)
- `owner`, `name` — split components of `modelId`
- `displayName` — model's human-readable title (e.g. `FLUX.1 [dev]`)
- `description` — model tagline/summary
- `runCount` — exact total API run count
- `isOfficial` — true if Replicate marks this as an official, publisher-maintained model
- `userType` — `organization` or `user`
- `hardware` — GPU/CPU class the model runs on (e.g. `H100`, `CPU`)
- `visibility` — `public` or `private`
- `latestVersion` — latest model version ID (hash)
- `latestVersionCreatedAt` — ISO timestamp of the latest version
- `pricing[]` — Replicate's published per-unit pricing (`{title, price, metric, note, variant}`); one entry per billing tier x metric, e.g. per output image, per second of video, per input/output token. `variant` distinguishes resolution/mode-gated tiers when a model has more than one (e.g. 480p vs 1080p video)
- `avatarUrl` — model owner's avatar image
- `coverImageUrl` — model's cover/example image
- `modelUrl` — the Replicate page for this model
- `sourceUrl` — same as `modelUrl` (canonical page scraped)
- `recordType: "model"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `trending` | `trending` / `byCollection` / `byOwner` / `byModelIds` / `search` |
| `collection` | string | `text-to-image` | (mode=byCollection) One of 39 task collections |
| `ownerName` | string | – | (mode=byOwner) Replicate username/org, e.g. `black-forest-labs` |
| `modelIds` | array | – | (mode=byModelIds) `owner/model-name` strings to look up directly |
| `searchQuery` | string | – | (mode=search) Keyword matched against owner, name, and blurb in the trending catalog |
| `minRuns` | int | `0` | Only include models with at least this many total runs |
| `officialOnly` | boolean | `false` | Only include Replicate-official models |
| `maxItems` | int | `10` | Maximum models to return (1–200) |

`trending` / `byCollection` / `byOwner` / `search` each list from a single Replicate listing page, so the number of models actually available is capped by how many that page shows (typically 80–140 depending on the page) — `maxItems` above that ceiling returns everything the page has rather than an error. Use `byModelIds` to fetch any additional specific models by name.

### Examples

#### Example: trending models

```json
{
  "mode": "trending",
  "maxItems": 20
}
````

#### Example: browse the text-to-video collection

```json
{
  "mode": "byCollection",
  "collection": "text-to-video",
  "maxItems": 10
}
```

#### Example: all models by a creator

```json
{
  "mode": "byOwner",
  "ownerName": "black-forest-labs",
  "maxItems": 30
}
```

#### Example: look up specific models

```json
{
  "mode": "byModelIds",
  "modelIds": ["black-forest-labs/flux-dev", "anthropic/claude-4.5-sonnet"]
}
```

#### Example: search with a popularity floor

```json
{
  "mode": "search",
  "searchQuery": "upscale",
  "minRuns": 100000,
  "maxItems": 10
}
```

### Use cases

- **AI tooling research** — track which image/video/LLM models are trending on Replicate
- **Vendor comparison** — compare run counts and hardware requirements across models in a task category
- **Model discovery** — find every model published by a specific lab (e.g. `black-forest-labs`, `bytedance`)
- **Catalog mirroring** — sync a curated model directory for an internal AI tools portal
- **Market signal tracking** — monitor a collection (e.g. `language-models`, `text-to-video`) for new releases and their adoption via `runCount`

### FAQ

**Is this affiliated with Replicate?**
No — this is an independent, third-party actor that reads Replicate's public model pages. It is not affiliated with or endorsed by Replicate.

**Does this actor run models or call the Replicate API?**
No. It only reads publicly published model listing pages — it does not run predictions, and no Replicate API token is used or required.

**What does `runCount` measure?**
The total number of times a model's API has been called, as published on the model's own Replicate page.

**Why does `search` only match the trending catalog?**
Replicate's full-text search is a client-side JavaScript widget with no public unauthenticated API. `search` mode filters the same trending/featured catalog used by `trending` mode by keyword. For an exhaustive search of one creator's or one task's models, use `byOwner` or `byCollection` instead.

**Why do some models lack a `hardware` or `latestVersion` field?**
Those fields are omitted (not returned as empty) when a model's page doesn't publish them — for example, some API-only models list `CPU` while GPU-hosted models list the exact GPU class.

**How fresh is the data?**
Every run fetches live pages directly from replicate.com — there is no caching layer.

# Actor input Schema

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

What to fetch from Replicate.

## `collection` (type: `string`):

(mode=byCollection) Task collection to browse — Replicate's curated topic/task taxonomy.

## `ownerName` (type: `string`):

(mode=byOwner) Replicate username or organization slug — e.g. `black-forest-labs`, `anthropic`, `stability-ai`.

## `modelIds` (type: `array`):

(mode=byModelIds) Models to look up, in `owner/model-name` format — e.g. `black-forest-labs/flux-dev`.

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

(mode=search) Keyword matched against owner, model name, and blurb across the trending catalog — e.g. `llama`, `upscale`, `voice`.

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

Optional filter: only include models with at least this many total API runs.

## `officialOnly` (type: `boolean`):

Only include models Replicate marks as official (maintained by the model's original publisher).

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

Maximum number of models to return.

## Actor input object example

```json
{
  "mode": "trending",
  "collection": "text-to-image",
  "ownerName": "black-forest-labs",
  "modelIds": [
    "black-forest-labs/flux-dev"
  ],
  "searchQuery": "llama",
  "minRuns": 0,
  "officialOnly": false,
  "maxItems": 10
}
```

# Actor output Schema

## `models` (type: `string`):

Dataset containing all scraped Replicate AI models.

# 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 = {
    "mode": "trending",
    "collection": "text-to-image",
    "ownerName": "black-forest-labs",
    "modelIds": [
        "black-forest-labs/flux-dev"
    ],
    "searchQuery": "llama",
    "minRuns": 0,
    "officialOnly": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/replicate-ai-explore-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 = {
    "mode": "trending",
    "collection": "text-to-image",
    "ownerName": "black-forest-labs",
    "modelIds": ["black-forest-labs/flux-dev"],
    "searchQuery": "llama",
    "minRuns": 0,
    "officialOnly": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/replicate-ai-explore-scraper").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 '{
  "mode": "trending",
  "collection": "text-to-image",
  "ownerName": "black-forest-labs",
  "modelIds": [
    "black-forest-labs/flux-dev"
  ],
  "searchQuery": "llama",
  "minRuns": 0,
  "officialOnly": false,
  "maxItems": 10
}' |
apify call crawlerbros/replicate-ai-explore-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/replicate-ai-explore-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Replicate AI Model Explore Scraper",
        "description": "Scrape Replicate's public model catalog (replicate.com/explore) - browse trending AI models, filter by one of 39 task collections (text-to-image, LLMs, video, audio), browse a creator's models, or look up models by owner/name. Extracts run counts, descriptions, cover images, versions.",
        "version": "1.0",
        "x-build-id": "cJRiMYvHZUEfKfRuc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~replicate-ai-explore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-replicate-ai-explore-scraper",
                "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/crawlerbros~replicate-ai-explore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-replicate-ai-explore-scraper",
                "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/crawlerbros~replicate-ai-explore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-replicate-ai-explore-scraper",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "trending",
                            "byCollection",
                            "byOwner",
                            "byModelIds",
                            "search"
                        ],
                        "type": "string",
                        "description": "What to fetch from Replicate.",
                        "default": "trending"
                    },
                    "collection": {
                        "title": "Collection",
                        "enum": [
                            "text-to-image",
                            "video-to-text",
                            "text-to-speech",
                            "ai-face-generator",
                            "text-to-video",
                            "super-resolution",
                            "ai-music-generation",
                            "image-editing",
                            "speech-to-text",
                            "text-recognition-ocr",
                            "remove-backgrounds",
                            "flux",
                            "ai-image-restoration",
                            "ai-enhance-videos",
                            "detect-nsfw-content",
                            "text-classification",
                            "speaker-diarization",
                            "face-swap",
                            "sketch-to-image",
                            "generate-emoji",
                            "generate-anime",
                            "image-to-video",
                            "vision-models",
                            "image-to-text",
                            "video-editing",
                            "wan-video",
                            "3d-models",
                            "official",
                            "language-models",
                            "try-for-free",
                            "lipsync",
                            "control-net",
                            "embedding-models",
                            "ai-detect-objects",
                            "flux-fine-tunes",
                            "flux-kontext-fine-tunes",
                            "sing-with-voices",
                            "utilities",
                            "qwen-image-fine-tunes"
                        ],
                        "type": "string",
                        "description": "(mode=byCollection) Task collection to browse — Replicate's curated topic/task taxonomy.",
                        "default": "text-to-image"
                    },
                    "ownerName": {
                        "title": "Owner / creator username",
                        "type": "string",
                        "description": "(mode=byOwner) Replicate username or organization slug — e.g. `black-forest-labs`, `anthropic`, `stability-ai`."
                    },
                    "modelIds": {
                        "title": "Model IDs",
                        "type": "array",
                        "description": "(mode=byModelIds) Models to look up, in `owner/model-name` format — e.g. `black-forest-labs/flux-dev`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "(mode=search) Keyword matched against owner, model name, and blurb across the trending catalog — e.g. `llama`, `upscale`, `voice`."
                    },
                    "minRuns": {
                        "title": "Minimum run count",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "integer",
                        "description": "Optional filter: only include models with at least this many total API runs.",
                        "default": 0
                    },
                    "officialOnly": {
                        "title": "Official models only",
                        "type": "boolean",
                        "description": "Only include models Replicate marks as official (maintained by the model's original publisher).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of models to return.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
