# Hugging Face Scraper β AI Models, Datasets & Spaces (`haketa/huggingface-scraper`) Actor
Scrape Hugging Face models, datasets and Spaces with downloads, likes, trending scores, licenses, tags and authors. Search by keyword or author, sort by popularity, and export clean JSON or CSV for LLM research, model discovery and AI market analysis. Ideal for ML teams and AI product research.
- **URL**: https://apify.com/haketa/huggingface-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## 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.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## Hugging Face Scraper β AI Models, Datasets & Spaces
**Collect Hugging Face models, datasets and Spaces as clean, structured data β ready for LLM research, ML model discovery and AI market analysis.**
***
### π Contents
- [At a glance](#-at-a-glance)
- [What this Hugging Face scraper does](#-what-this-hugging-face-scraper-does)
- [Key features](#-key-features)
- [Who it is for](#-who-it-is-for)
- [Use cases](#-use-cases)
- [How it works](#-how-it-works)
- [Step-by-step usage](#-step-by-step-usage)
- [Input](#-input)
- [Output](#-output)
- [Proven results (local verification)](#-proven-results-local-verification)
- [Integrations](#-integrations)
- [Tips for better results](#-tips-for-better-results)
- [Limitations](#-limitations)
- [FAQ](#-faq)
- [Keywords](#-keywords)
- [Disclaimer](#-disclaimer)
***
### β‘ At a glance
| | |
|---|---|
| **What you collect** | AI models, datasets and Spaces (demos & apps) from Hugging Face |
| **Search by** | Keyword(s), author or organization β or leave empty for a popular sample |
| **Sort by** | Most downloads Β· Most likes Β· Trending now Β· Newest first Β· Recently updated |
| **Key fields** | Downloads, likes, trending score, task, library, license, languages, tags, author, dates |
| **Empty run** | Still returns about 100 popular models β useful results with zero setup |
| **Output formats** | JSON, CSV, Excel, HTML and XML via the Apify Console export |
| **Code required** | None β fill in a short form and press Start |
| **Typical run** | 100 records in seconds; larger targeted runs scale with `Max results` |
***
### π€ What this Hugging Face scraper does
Hugging Face is where the open AI ecosystem publishes its work: hundreds of
thousands of ML models, training datasets and interactive Spaces. Browsing that
catalogue by hand is slow, and copying names, download counts and licenses into
a spreadsheet does not scale.
This **Hugging Face scraper** turns the catalogue into a dataset you can
actually work with. Tell it what you are looking for β for example all models
matching βllamaβ, everything published by one organization, or the most liked
Spaces right now β and it returns one clean record per item with the numbers
and metadata that matter:
- how popular it is (**downloads**, **likes**, **trending score**),
- what it does (**task / pipeline**, **library**, **SDK**),
- whether you may use it (**license**, **gated** status),
- who published it (**author**), when it appeared and when it last changed,
- and a direct link back to its Hugging Face page.
Whether you are building an **AI models dataset** for analysis, tracking an
**LLM leaderboard**, shortlisting open-source models for a product, or mapping
which datasets power modern training runs, this actor gives you the raw
material in minutes instead of days of manual browsing.
***
### β¨ Key features
- **Three catalogues in one actor** β switch between Models, Datasets and
Spaces with a single dropdown. No separate tools to learn.
- **Keyword search that merges cleanly** β add several search terms and get
one combined, de-duplicated result set.
- **Author / organization filter** β watch a single publisher such as a lab,
a company or a prolific community member.
- **Five sort orders** β most downloads, most likes, trending now, newest
first or recently updated, so the items you care about surface first.
- **License extracted for you** β the license is pulled out of the raw tags
into its own field, ready for filtering and compliance checks.
- **Languages kept as data** β language information stays as a proper list,
not a flattened string, so you can filter multilingual coverage easily.
- **Works with an empty form** β press Start without typing anything and
still get about 100 popular models to explore.
- **Sensible size control** β cap a run at exactly the number of records
you need, or run a targeted search without a cap.
- **Clean, analysis-ready records** β consistent field names across models,
datasets and Spaces, with empty values left out instead of cluttering
your export.
- **Export anywhere** β download JSON, CSV or Excel, or send results to
your stack with Apify integrations and the API.
***
### π₯ Who it is for
- **ML engineers and researchers** shortlisting models or datasets for a
project, a benchmark or a paper.
- **AI product teams** tracking competitors, trending techniques and new
releases in their space.
- **Data analysts** building AI market datasets, trend reports and internal
dashboards.
- **Developer-relations and community teams** following authors and
organizations that matter to their ecosystem.
- **Students and curious builders** who want a real, explorable sample of
the open AI catalogue without writing code.
***
### π‘ Use cases
#### 1. Build an LLM shortlist for a new product
Search for your task (for example βtext-generationβ), sort by downloads,
and compare candidates side by side: downloads and likes show adoption,
the task and library fields show fit, and the license field shows what you
are allowed to ship. Export to a spreadsheet and score the shortlist with
your team instead of juggling dozens of browser tabs.
#### 2. Track what is trending in open AI
Sort any catalogue by **Trending now** and run the actor on a schedule.
Diff this week's export against last week's and you have a simple,
repeatable pulse on which models, datasets and demos the community is
rallying around β useful input for roadmaps, content and research planning.
#### 3. Follow one lab or organization
Put an organization in the **Author** field (for example a model lab) and
collect everything it has published. Sort by newest first to catch fresh
releases, or by downloads to see which of its releases actually landed.
#### 4. Assemble training-data candidates
Switch to **Datasets**, search by topic or task, and use downloads, likes,
languages and license to triage candidates before you inspect them in
detail. The description field helps you discard obvious mismatches early.
#### 5. Discover demos worth trying (or learning from)
Spaces are working demos, not just weights. Sort Spaces by likes or
trending score to find interfaces people love, see which SDK they use,
and open the linked page to try them yourself.
#### 6. Feed an internal AI catalogue or dashboard
Run the actor via the Apify API or on a schedule and pipe the dataset
into your warehouse, BI tool or internal search. Consistent fields across
runs make week-over-week comparisons straightforward.
#### 7. Support academic and market research
Build a citable snapshot of the open model ecosystem at a point in time:
counts by task, library, license and language, adoption distributions,
and release velocity β all from one export instead of manual sampling.
***
### βοΈ How it works
1. **You describe what you want** β pick Models, Datasets or Spaces,
optionally add keywords and an author, and choose a sort order.
2. **The actor collects matching listings** from Hugging Face's public
catalogue, page by page, until it reaches your result cap.
3. **Records are tidied as they arrive** β duplicates are removed, the
license and languages are lifted into their own fields, and each item
gets a direct link to its Hugging Face page.
4. **You get a dataset** in the Apify Console: preview it in the table,
filter it, and export it as JSON, CSV or Excel β or pull it through
the API.
No setup, no scripts and nothing to maintain on your side. If you leave
every field empty, the actor simply collects a popular sample of about
100 models so you can see the output shape right away.
***
### π Step-by-step usage
1. Open the actor in the Apify Console and go to the **Input** tab.
2. Choose **What to scrape**: Models, Datasets or Spaces.
3. (Optional) Add one or more **Search keywords**, e.g. `llama`.
4. (Optional) Add an **Author or organization** to limit results to one
publisher.
5. Pick **Sort results by** β βMost downloadsβ is a solid default.
6. Set **Max results** to the size you want (100 is a good first run).
7. Press **Start** and watch the live log and status counter.
8. When the run finishes, open the **Dataset** tab to preview records.
9. Use **Export** to download JSON, CSV or Excel β or open the
**Integrations** tab to send data onward automatically.
10. Re-run any time; try scheduling weekly runs to build a time series.
***
### π₯ Input
Every field is optional. Start with the defaults, then narrow down.
| Field | What it does | Example |
|---|---|---|
| **What to scrape** | Pick the catalogue: Models, Datasets or Spaces | `models` |
| **Search keywords** | One or more keywords; each is searched and merged without duplicates | `llama`, `sentiment` |
| **Author or organization** | Only items from one publisher | `meta-llama` |
| **Sort results by** | Most downloads, most likes, trending, newest or recently updated | `downloads` |
| **Max results** | Cap on records collected; `0` means no cap on targeted searches | `100` |
| **Proxy configuration** | Connection settings; the default is right for most runs | default |
#### Example 1 β Instant popular sample (zero setup)
```json
{}
```
Returns about 100 popular models, sorted by downloads.
#### Example 2 β LLM discovery by keyword
```json
{
"entityType": "models",
"searchTerms": ["llama"],
"sort": "downloads",
"maxItems": 100
}
```
#### Example 3 β Watch one organization, trending first
```json
{
"entityType": "models",
"author": "meta-llama",
"sort": "trendingScore",
"maxItems": 50
}
```
#### Example 4 β Dataset hunting
```json
{
"entityType": "datasets",
"searchTerms": ["instruction tuning"],
"sort": "downloads",
"maxItems": 100
}
```
#### Example 5 β Demo discovery in Spaces
```json
{
"entityType": "spaces",
"searchTerms": ["image generation"],
"sort": "likes",
"maxItems": 100
}
```
***
### π€ Output
Each run produces one record per model, dataset or Space. Field names are
the same across all three catalogues, so exports are easy to combine and
compare. Empty values are simply left out of a record.
**Coverage legend** (from the local verification runs below):
π’ present for nearly every record Β· π‘ present when the publisher provides
it Β· βͺ present for a smaller share of records.
#### Identity & popularity
| Field | Meaning | Coverage |
|---|---|---|
| `entityType` | `models`, `datasets` or `spaces` | π’ 30/30 Β· 20/20 Β· 20/20 in tests |
| `id` | Full name, e.g. `meta-llama/Llama-3.1-8B-Instruct` | π’ every record |
| `author` | Publisher (user or organization) | π’ every record |
| `downloads` | All-time downloads (models & datasets) | π’ 30/30 models Β· 20/20 datasets |
| `likes` | Community likes | π’ every record |
| `trendingScore` | Trending score when ranked by trending | π‘ 10/10 in a trending run; not shown for download ranking |
#### Classification & licensing
| Field | Meaning | Coverage |
|---|---|---|
| `pipelineTag` | Task, e.g. `text-generation` (models) | π’ 29/30 in model test |
| `libraryName` | Library, e.g. `transformers` (models) | π’ 27/30 in model test |
| `sdk` | App SDK, e.g. `gradio`, `docker` (Spaces) | π’ 20/20 in Spaces test |
| `license` | License lifted out of the tags, e.g. `mit`, `apache-2.0` | π‘ 26/30 models Β· 12/20 datasets Β· 14/20 Spaces |
| `languages` | Language codes as a list, when declared | βͺ 7/20 datasets; rarely declared elsewhere |
| `tags` | Full tag list as published | π’ every record |
#### Content & provenance
| Field | Meaning | Coverage |
|---|---|---|
| `description` | Publisher description (datasets & Spaces, shortened if very long) | π‘ 13/20 datasets Β· 12/20 Spaces |
| `gated` | Access gating: open, manual approval or similar (models & datasets) | π’ 30/30 models Β· 20/20 datasets |
| `sha` | Current revision identifier | π’ every record |
| `createdAt` | When the item was published | π’ every record |
| `lastModified` | When the item last changed | π’ every record |
| `url` | Direct link to the Hugging Face page | π’ every record |
| `scrapedAt` | When this actor collected the record | π’ every record |
#### Example output record
```json
{
"entityType": "models",
"id": "meta-llama/Llama-3.1-8B-Instruct",
"author": "meta-llama",
"downloads": 4864172,
"likes": 8573,
"pipelineTag": "text-generation",
"libraryName": "transformers",
"license": "llama3.1",
"tags": ["transformers", "safetensors", "llama", "text-generation", "license:llama3.1"],
"gated": "manual",
"sha": "0e9e39f249a16976918f6564b8830bc894c89659",
"createdAt": "2024-07-18T08:56:00.000Z",
"lastModified": "2024-09-25T17:00:57.000Z",
"url": "https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct",
"scrapedAt": "2026-10-23T13:40:27.263Z"
}
```
***
### β
Proven results (local verification)
This actor was run locally before release. All numbers below are from
those real runs β same code, same output shape you will receive.
| Check | Input | Result |
|---|---|---|
| Keyword search | Models Β· `llama` Β· most downloads Β· max 30 | **30 records**, 30 unique IDs |
| Author watch | Models Β· author `meta-llama` Β· trending Β· max 10 | **10 records**, every author `meta-llama`, trending score on 10/10 |
| Datasets sample | Datasets Β· most downloads Β· max 20 | **20 records** with descriptions on 13/20 |
| Spaces sample | Spaces Β· most likes Β· max 20 | **20 records**, SDK on 20/20 |
| Empty run | `{}` (nothing typed at all) | **100 popular models** |
| Pagination capacity | Model listing, page after page | **1,100 models in 11 pages**, more pages still available afterwards |
Field fill highlights from those runs:
- Identity and links were complete: `id`, `author`, `url`, `entityType`
and `scrapedAt` appeared on every record checked.
- Popularity was complete: `downloads` and `likes` appeared on every
model and dataset record; `likes` on every Space.
- Dates and revision (`createdAt`, `lastModified`, `sha`) appeared on
every record checked.
- Model classification was near-complete in the keyword test:
task on 29 of 30 records, library on 27 of 30.
- License β the field teams usually clean by hand β was already
separated out on 26 of 30 models, 12 of 20 datasets and 14 of 20 Spaces.
The rest simply do not declare a license.
- Sample links were opened and answered successfully for all three
catalogues: a model page, a dataset page and a Space page.
What this means for you: the core columns you will filter and sort on
arrive filled. Optional columns reflect what publishers themselves
provide β nothing is padded with invented values.
***
### π Integrations
Because results live in a standard Apify dataset, they flow into the
tools you already use:
- **Spreadsheets** β export CSV or Excel, or connect Google Sheets to
refresh a workbook on a schedule.
- **Databases & warehouses** β pull the dataset through the Apify API
into Postgres, BigQuery, Snowflake or your internal catalogue.
- **Automation platforms** β trigger Make, Zapier or n8n workflows when
a scheduled run finishes (for example: βnew model from a watched labβ).
- **Chat alerts** β post a Slack or email digest of trending items
after each weekly run.
- **BI dashboards** β feed Looker Studio, Tableau or Power BI from the
exported data for an always-current AI landscape view.
- **Custom code** β call the actor from the Apify API / SDKs in your
own pipeline and read structured JSON back.
A typical pattern: schedule the actor weekly with your keywords, then
let an automation diff and summarize what changed.
***
### π‘ Tips for better results
- **Start broad, then narrow.** Run the empty sample first to see the
output shape, then add keywords.
- **Combine keywords thoughtfully.** Each keyword is searched on its
own; overlapping terms are de-duplicated, so synonyms are safe.
- **Use the author filter for watchlists.** One run per important lab
beats one giant mixed export you have to slice later.
- **Match the sort to the question.** Downloads answer βwhat is
adopted?β, trending answers βwhat is hot now?β, newest answers
βwhat just shipped?β.
- **Filter by license early.** If you plan to ship commercially, export
and filter the `license` column before deeper evaluation.
- **Keep runs comparable.** Same input on a schedule gives you a clean
time series; changing inputs mid-series breaks comparisons.
- **Raise `Max results` gradually.** 100 records is fast and cheap for
exploration; scale up once you know the query is right.
***
### β οΈ Limitations
- **Public listings only.** The actor collects catalogue metadata for
publicly visible models, datasets and Spaces. It does not download
model weights, dataset files or Space source code.
- **Gated items show metadata, not contents.** For access-controlled
items you still get counts, license and dates β the underlying files
remain behind Hugging Face's own access flow.
- **Coverage mirrors the publishers.** If a publisher declares no
license, description or languages, those fields stay empty. The actor
never invents values to fill a column.
- **Trending scores are contextual.** A trending score is published
alongside trending-ranked results; download- or date-ranked exports
focus on those rankings instead.
- **Very long descriptions are shortened** to keep records readable;
follow the `url` for the full publisher text.
- **Counts move.** Downloads, likes and trending scores change
constantly β treat each run as a timestamped snapshot (`scrapedAt`).
***
### β FAQ
#### Do I need a Hugging Face account or API key?
No. The actor works with public catalogue information. Just press Start.
#### What happens if I run it with no input at all?
You still get data: about 100 popular models sorted by downloads.
It is the fastest way to see exactly what the output looks like.
#### Can I scrape datasets or Spaces instead of models?
Yes β change **What to scrape** to Datasets or Spaces. Keywords, author,
sorting and the result cap work the same way, and the output fields keep
the same names.
#### How do I get everything from one company or lab?
Put its name in **Author or organization** (for example `meta-llama`),
leave keywords empty, and raise **Max results** β or set it to `0` for a
targeted run without a cap.
#### What does `0` in Max results mean?
No cap for that run. On a targeted search the actor keeps going until
the catalogue results run out. An empty, filter-less run is still capped
at a fast sample size so a stray click never turns into a huge job.
#### Is the license field reliable enough for compliance work?
It reflects the license the publisher declares, lifted into its own
field so you can filter and review it at scale. Treat it as your
triage list and confirm the full license text on the item's page before
making legal decisions.
#### Why is trendingScore missing in my export?
Trending scores travel with trending-ranked listings. Sort by
**Trending now** when that number matters; other rankings omit it by
design rather than filling it with a stale value.
#### Can I run this on a schedule and track changes?
Yes. Schedule identical inputs (weekly works well) and compare exports
by `id` and `scrapedAt`. New IDs are new releases; changing counts show
momentum.
#### Which export format should I choose?
CSV or Excel for spreadsheet work, JSON for code and pipelines. The
Console preview table is handy for a quick look and light filtering.
#### Does it download the actual models or datasets?
No β it collects the catalogue record (metadata, counts, license, links).
That keeps runs fast and storage small. Use each record's `url` to open
the item and obtain files through Hugging Face itself.
***
### π Keywords
Hugging Face scraper Β· Hugging Face models scraper Β· AI models dataset Β·
ML model discovery Β· LLM leaderboard data Β· open-source LLM list Β·
Hugging Face datasets export Β· Hugging Face Spaces scraper Β·
transformers model catalogue Β· model license checker data Β·
AI market research data Β· trending AI models Β· LLM comparison data Β·
machine learning dataset discovery
***
### π Disclaimer
This is an independent tool for collecting publicly available catalogue
information. **Not affiliated with Hugging Face.** Hugging Face is a
trademark of its respective owner; product and organization names appear
here only to describe what the data refers to. Please respect Hugging
Face's terms and each publisher's license when using collected data.
# Actor input Schema
## `entityType` (type: `string`):
Choose what you want to collect: AI models, datasets or Spaces (interactive demos and apps).
## `searchTerms` (type: `array`):
Keywords to search for, e.g. "llama", "text-generation" or "sentiment". Each keyword runs as its own search and results are merged without duplicates. Leave empty for a popular sample.
## `author` (type: `string`):
Only return items from one author or organization, e.g. "meta-llama", "openai" or "nvidia". Leave empty to search across everyone.
## `sort` (type: `string`):
Control which items come first: most downloaded, most liked, trending now, newest or most recently updated.
## `maxItems` (type: `integer`):
Maximum number of results to collect across all searches. Use 0 for no limit on a targeted search. An empty run with no keywords is capped at about 100 results so you get a fast, useful sample.
## `proxyConfiguration` (type: `object`):
Proxy settings for the run. The default works well for most runs and helps keep collection smooth at scale.
## Actor input object example
```json
{
"entityType": "models",
"searchTerms": [
"llama"
],
"sort": "downloads",
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (type: `string`):
Open to view, filter and export all scraped results from this run (JSON, CSV, Excel).
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"entityType": "models",
"searchTerms": [
"llama"
],
"author": "",
"sort": "downloads",
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("haketa/huggingface-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"entityType": "models",
"searchTerms": ["llama"],
"author": "",
"sort": "downloads",
"maxItems": 100,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("haketa/huggingface-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 '{
"entityType": "models",
"searchTerms": [
"llama"
],
"author": "",
"sort": "downloads",
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call haketa/huggingface-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/huggingface-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 ` 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/hILajG3IRudOD0Mpp/builds/89IkmLJjqf5HfXxmz/openapi.json