Replicate AI Model Explore Scraper: 19 Data Fields per Record (2026)

Each record carries 19 fields, including the exact API run count, hardware requirements like GPU class, and detailed per-unit pricing tiers. This scraper retrieves the latest version IDs and ISO timestamps for public AI models, allowing you to monitor the adoption of new LLMs and image generators across 39 task collections. It returns structured data for trending models, specific creators, or keyword searches without requiring a Replicate API key. This is ideal for researchers building internal AI directories or tracking market signals, but it is not for users who need to execute model predictions or download model weights.

Try it: open Replicate AI Model Explore Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Replicate AI Model Explore Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Replicate AI Model Explore Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 10, so a first run returns at most 10 results and costs at most $0.05 in result charges. That is enough to see the real shape of the data before deciding anything.

Replicate AI Model Explore Scraper was last updated on 2026-07-11. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 680,173 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Replicate AI Model Explore Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems control has the largest effect on your bill as it directly limits the number of model records written to the dataset. To see if the fields like hardware and pricing fit your needs before a full crawl, run the example input which caps results at 10 and costs at most $0.05.

How do you run Replicate AI Model Explore Scraper from the API?

The schema marks 1 of its 8 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Replicate AI Model Explore Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~replicate-ai-explore-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"trending","collection":"text-to-image","ownerName":"black-forest-labs","modelIds":["black-forest-labs/flux-dev"],"searchQuery":"llama","minRuns":0,"officialOnly":false,"maxItems":10}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

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 = client.actor("crawlerbros~replicate-ai-explore-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

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
}

const run = await client.actor('crawlerbros~replicate-ai-explore-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Replicate AI Model Explore Scraper inputs matter, and which can you skip?

The mode control is the primary setting, switching between browsing trending models, task collections, or specific creators. For most discovery tasks, the collection dropdown and searchQuery are the only other fields to change, while filters like officialOnly help narrow the results to verified publishers.

• mode (string): What to fetch from Replicate. Default: "trending".
• collection (string): (mode=byCollection) Task collection to browse - Replicate's curated topic/task taxonomy. Default: "text-to-image".
• ownerName (string): (mode=byOwner) Replicate username or organization slug - e.g. black-forest-labs, anthropic, stability-ai.
• modelIds (array): (mode=byModelIds) Models to look up, in owner/model-name format - e.g. black-forest-labs/flux-dev.
• searchQuery (string): (mode=search) Keyword matched against owner, model name, and blurb across the trending catalog - e.g. llama, upscale, voice.
• minRuns (integer): Optional filter: only include models with at least this many total API runs. Default: 0.
• officialOnly (boolean): Only include models Replicate marks as official (maintained by the model's original publisher). Default: false.
• maxItems (integer): Maximum number of models to return. Default: 10.

Fixed-choice controls: mode accepts trending (Trending / featured models), byCollection (Browse a task collection), byOwner (Browse a creator's models), byModelIds (Look up specific models by owner/name), search (Search by keyword); collection accepts 39 values (default text-to-image), including text-to-image (Generate images (text-to-image)), video-to-text (Caption videos), text-to-speech (Generate speech (text-to-speech)), ai-face-generator (Generate images from a face).

What does Replicate AI Model Explore Scraper return?

The returned records are effective for market analysis because they include live run counts and pricing metrics extracted directly from individual model pages. They do not contain model weights, code files, or the ability to run inference, as the output is restricted to directory metadata.

• 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

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Replicate AI Model Explore Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set the mode control to define your target, such as using byCollection to find models grouped under a specific task taxonomy.
2. Select your target category from the collection dropdown list, such as text-to-image or language-models.
3. Input a numeric threshold in the minRuns field to filter out experimental models and keep only those with proven API usage.
4. Set the maxItems limit to 10 for your initial test run to verify the schema without consuming excess platform usage.
5. Run the Actor and inspect the dataset to ensure the modelId matches the expected owner/model-name string structure.
6. Examine the nested pricing array in the output to confirm that the metric and variant fields are populated.
7. Enable the officialOnly checkbox to filter out community forks and isolate publisher-maintained models.
8. Download the dataset as a JSON file to preserve the structured array formatting of the pricing and latestVersion metadata.

How do you apply it? Three worked playbooks

These are Replicate AI Model Explore Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: AI tooling research

Outcome: Track which image/video/LLM models are trending on Replicate

Configure: mode set to "trending", maxItems set to 50, and officialOnly set to false.

Working method: Initialize the Actor in trending mode to extract the featured models directory. Analyze the modelId and description fields to classify emerging modalities. Run this daily to trace which new models are rising in popularity based on changes in the collected dataset.

Deliverable: A spreadsheet tracking the top 50 trending models, including their descriptions and developer usernames.

Stop condition: The resulting dataset contains fewer than 10 models despite a high maxItems configuration.

Use case 2: Vendor comparison

Outcome: Compare run counts and hardware requirements across models in a task category

Configure: mode set to "byCollection", collection set to "language-models", and minRuns set to 5000.

Working method: Retrieve the models list within the language-models collection. Map the hardware field against the pricing array to compare the cost-efficiency of different models operating on identical GPU tiers. Cross-reference the runCount to determine if cheaper models are gaining traction.

Deliverable: A comparative index mapping model hardware requirements, per-token pricing structures, and run counts within a single task category.

Stop condition: The hardware field is completely omitted from more than half of the retrieved model records.

Use case 3: Model discovery

Outcome: Find every model published by a specific lab (e.g. black-forest-labs, bytedance)

Configure: mode set to "byOwner", ownerName set to "black-forest-labs", and maxItems set to 100.

Working method: Run the Actor with mode configured to byOwner and specify the organization username. Analyze the latestVersionCreatedAt timestamps of the returned records to map out the publisher's release timeline. Group the discovered items by their isOfficial status.

Deliverable: A structured database cataloging all public models released by a designated creator or organization.

Stop condition: The dataset returns zero records for a known active creator name.

What breaks, and how do you design around it?

If you need more than the 80 to 140 models typically shown on a listing page, use the byModelIds mode to fetch specific missing models by their slug. When a model page does not publish hardware details or a version hash, those specific fields are omitted from the record.

When should you not use Replicate AI Model Explore Scraper?

Do not use this Actor if you need to automate the execution of AI models or retrieve model output files, as it only extracts directory metadata. If your research focuses on community-driven image generation models and LoRAs rather than API-hosted infrastructure, the Civitai Models & Creators Scraper is the better choice for tracking model files and prompt metadata. For enterprise-grade software and cloud services rather than individual AI weights, the AWS Marketplace Scraper provides more relevant data. Finally, avoid this tool if you require unauthenticated full-text search across the entire Replicate database; the search mode is limited to filtering the trending catalog.

What should you check before trusting the output?

• Verify that the runCount field is populated with a valid integer to ensure popularity metrics were captured.
• Check if the hardware field is missing on certain records, confirming it was omitted because the public page lacks GPU details.
• Verify that latestVersionCreatedAt contains a valid ISO timestamp before performing time-series analysis.
• Confirm that the pricing array contains multiple records with unique variant tags for models that gate pricing by resolution.
• Check that the modelUrl starts with a valid replicate.com path for records designated with a recordType of model.

None of this proves a record is correct. It gives a scheduled Replicate AI Model Explore Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape 1,000 models?

On the free-plan price of $5.00 per 1,000 results, scraping 1,000 model records would cost exactly $5.00 in result charges. Note that this does not include the run-start fee or platform usage costs. Apify's free plan includes $5.00 of monthly usage, which can cover up to 1,000 results if platform usage is minimal.

Can I trust the runCount for accuracy?

The Actor extracts the exact total API run count directly from each model's public Replicate page. Every run fetches live pages directly from the site without a caching layer, so the numbers reflect the current state of the Replicate directory at the moment you start the run.

Why are some fields like hardware missing from my results?

Empty fields are omitted from every record to keep the dataset structured. If a model owner has not specified a GPU class or if Replicate does not publish hardware details for that specific model, the hardware field will not appear in the output for that specific record.

Is a Replicate API token needed?

No. This Actor is an independent scraper that uses HTTP requests to read unauthenticated public pages. It does not call the Replicate API and does not consume your Replicate account credits or require any secret keys to retrieve the catalog data.

What is the maximum number of models I can fetch?

While the maxItems control can be set up to 200, listing pages on Replicate typically display between 80 and 140 models. If the number of models available on the page is below your maxItems setting, the Actor returns everything available rather than an error.

Where to go next

When you are ready to run it, open Replicate AI Model Explore Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Replicate AI Model Explore Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Civitai Models & Creators Scraper: Scrape Civitai, the largest AI art model sharing platform.
• TikTok Explore/Trending Scraper: Scrape TikTok's Explore/Trending feed across categories.
• WatchBox Scraper: Scrape TheWatchBox.com - one of the world's largest pre-owned luxury watch retailers.
• AWS Marketplace Scraper: Scrape AWS Marketplace product listings with search by keyword, browse by category, fetch specific product URLs, or explore free products.
• Seiko Watch Scraper (USA): Scrape Seiko USA watch listings - model numbers, collections, prices, images, and tags.
• Sketchfab 3D Model Scraper: Scrape Sketchfab.com - search or browse 3D models by keyword, category, license, price and more.
• Whop.com Scraper: Scrape Whop.com community listings by search query, category, or URL.
• Video Game Database Scraper: Search and explore structured video game metadata from Wikidata, 500K+ games with developer, publisher, platform, genre, release year, and description data.

Related guides:

• TikTok Hashtag Trends Scraper: Up to 1,000 Free Results a Month (2026)
• Sketchfab 3D Model Scraper: 41 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-27.

• Actor last updated by its maintainers on 2026-07-11.

• Run outcome figures cover the 30 day public window ending 2026-09-27.

• Replicate AI Model Explore Scraper on Apify