# 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/actors/running/actors-in-store.md#pay-per-event

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

## 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(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 '{
  "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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/replicate-ai-explore-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/qUQ4nlIMuZlGhGHAp/builds/cJRiMYvHZUEfKfRuc/openapi.json