# Hugging Face Hub: Models and Datasets With Download Counts (`yadroo/huggingface-hub-models`) Actor

Public Hugging Face Hub repositories as rows: model or dataset id, owner, task tag, library, licence, languages, 30-day and all-time downloads, likes, trending score, gated status, parameter count and commit dates. Filter by task, licence, owner, size or update window; sort as you need.

- **URL**: https://apify.com/yadroo/huggingface-hub-models.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** AI, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 repository rows

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 Hub: Models and Datasets With Download Counts

Turn the public Hugging Face Hub catalogue into a table. One run lists model **or** dataset repositories through the Hub's own public API and writes one row per repository: id, owner, task tag, library, licence, languages, downloads in the last 30 days and all time, likes, trending score, gated status, parameter count and precision, base models, creation and last-commit dates. Filter by task, licence, owner, language, size band or update window, sort the way the Hub sorts, and keep only the columns you need. For engineers choosing a model, teams reviewing licences, and agents that need today's shortlist. No API key, no proxy and no browser — only public metadata, never model or dataset files.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/huggingface-hub-models/issues) and describe what you need — we read every request and adapt the actor.

### Use cases

- **Shortlist a model for one task under a licence and a size limit**: text-generation models of at most 8B parameters under Apache 2.0, ranked by downloads — the list a self-hosting decision starts from.
- **Watch what one lab ships**: every public repository of `google`, `Qwen`, `meta-llama` or your own vendor list, with sizes, licences and commit dates, re-run on a schedule.
- **Today's trending repositories**: the Hub's own short-term ranking as rows, for a newsletter, a dashboard or an AI-watch agent.
- **Release tracking**: everything published or committed in the last 24 hours or 7 days in one field, with `onlyNew` so a scheduled run reports only what moved.
- **Find evaluation or training data**: datasets by task category, language, size band and format, with stored bytes and download counts next to each other.
- **Keep a catalogue table fresh**: one dataset that joins models and datasets in the same row shape, exported to a sheet, a warehouse or an agent's context.

### Input

Every field is optional. The keyword and the filters are combined with AND: a repository must satisfy all of them.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `repoType` | string (strict list) | `models` | `models` or `datasets`. One run reads one index. An off-list value is refused by the platform before the run starts, with the allowed values in the message. |
| `search` | string | — | Keyword handed to the Hub's own search (matched against id and owner). Travels exactly as typed; no correction. |
| `repoIds` | string\[] | — | Up to 50 exact ids (`Qwen/Qwen3-0.6B`, `cais/mmlu`) or Hub addresses. When set, the actor looks these up instead of searching, and each row carries the detail columns. An id the Hub does not serve anonymously becomes one row with `found: false`. |
| `pipelineTag` | string (free text + suggestions) | — | Models only. One Hub task id, e.g. `text-generation`. Case, spaces and separators are read the same; the aliases below are accepted; any other spelling stops the run and names the closest ids. See [Tasks](#tasks-pipelinetag-models). |
| `library` | string (free text + suggestions) | — | One library or weight format (`transformers`, `gguf`, `diffusers`, `mlx`, `polars` …), checked against the vocabulary of the chosen index. See [Libraries](#libraries). |
| `licenses` | string\[] | — | Up to 5 Hub licence ids (`apache-2.0`, `mit`, …), with or without the `license:` prefix. One request per value. See [Licences](#licences). |
| `languages` | string\[] | — | Up to 5 language codes (`en`, `ru`, `zh`). Lower-cased and passed through unchanged — no correction and no suggestions, because the Hub carries thousands of language tags. |
| `taskCategories` | string\[] | — | Datasets only. Up to 5 dataset task categories (`question-answering`, `text-generation`, …). See [Dataset task categories](#dataset-task-categories-taskcategories). |
| `tagFilters` | string\[] | — | Up to 10 raw Hub tags, all of which a repository must carry (`size_categories:1K<n<10K`, `modality:text`, `format:parquet`, `base_model:Qwen/Qwen3-0.6B`, `conversational`). Passed through unchanged. |
| `authors` | string\[] | — | Up to 25 owners. The Hub matches an owner case-sensitively; another case is looked up once on the Hub's own user or organisation record and re-queried in the canonical spelling, which the run status reports. One request per owner and page. |
| `minDownloads` | integer | — | Drop repositories with fewer 30-day downloads. Applied by the actor after reading the rows. |
| `minLikes` | integer | — | Drop repositories with fewer likes. |
| `minParametersMillions` | integer | — | Models only. `7000` = 7B. Repositories without a safetensors weight index have no count and drop out as soon as a bound is set. |
| `maxParametersMillions` | integer | — | Models only. `1000` = up to 1B. Set both for a band. |
| `gatedAccess` | string (strict list) | `any` | `any`, `open` (files downloadable by anyone) or `gated` (access must be requested). Off-list values are refused by the platform before the run. |
| `createdSince` | string (date) | — | Keep repositories first published on or after this date (`2026-01-31`). |
| `updatedSince` | string (date) | — | Keep repositories whose last commit is on or after this date. |
| `sinceHours` | integer | — | 1–8760. Rolling commit window counted in UTC from the run start; combined with the dates above, the later floor wins. |
| `onlyNew` | boolean | `false` | Remember what this input delivered and write only repositories that are new or whose commit changed since the last run. |
| `includeParameterCount` | boolean | `true` | Models: add `parameterCount` and `parameterPrecisions`. Costs no extra request. |
| `includeCardMetadata` | boolean | `true` | Add `license`, `baseModels` and the dataset `prettyName` from the card header. Costs no extra request. |
| `includeModelConfig` | boolean | `false` | Models: add `modelType` and `architectures` from the configuration file. No extra request, but a much larger response. |
| `includeRepoDetails` | boolean | `false` | Add `sha`, `fileCount`, `spacesCount`, `inferenceStatus` and, for models, `repoSizeBytes` — **one extra request per row**. |
| `sort` | string (strict list) | `downloads` | `downloads` (rolling 30 days), `likes`, `trendingScore`, `createdAt`, `lastModified`. All-time downloads cannot be sorted on. Off-list values are refused by the platform before the run. |
| `sortDirection` | string (strict list) | `desc` | `desc` works with every key. `asc` is served by the Hub for `createdAt` only; with any other key the run stops at once and the message names the two ways forward. |
| `maxItems` | integer | `25` | 1–1000. Hard cap on the rows written, and so on the cost. The Hub serves up to 100 repositories per request. |
| `fields` | string\[] | all | Keep only these columns, **in this order**. `id`, `repoType`, `found`, `url` and `fetchedAt` are always kept — the ones you do not list come first, a listed one stays where you put it. An unknown name is reported in the run status. |
| `hfToken` | string (secret) | — | Your own read-only Hugging Face token. Raises the Hub's quota for this run from 500 to 1,000 requests per 5 minutes and counts it against your account. Sent to the Hub only; never written to the dataset, the log or SUMMARY. It does not unlock gated or private repositories. |

**Strict lists vs free text.** `repoType`, `gatedAccess`, `sort` and `sortDirection` are closed lists: Apify refuses an off-list value with HTTP 400 before the run starts and the error names the allowed values, so there is nothing for the actor to correct. `pipelineTag`, `library`, `licenses` and `taskCategories` are free text with a dropdown of suggestions: case, spaces, separators, accents and the aliases listed below are accepted, and any other spelling stops the run with the closest ids named — never a wider result set. `search`, `languages` and `tagFilters` travel exactly as typed.

### Reference

#### Tasks (`pipelineTag`, models)

52 ids on 2026-10-21, and the Hub keeps adding them — this field accepts any id the Hub publishes, not only the list below:

`any-to-any`, `audio-classification`, `audio-text-to-text`, `audio-to-audio`, `automatic-speech-recognition`, `depth-estimation`, `document-question-answering`, `feature-extraction`, `fill-mask`, `graph-ml`, `image-classification`, `image-feature-extraction`, `image-segmentation`, `image-text-to-image`, `image-text-to-text`, `image-text-to-video`, `image-to-3d`, `image-to-image`, `image-to-text`, `image-to-video`, `keypoint-detection`, `mask-generation`, `object-detection`, `question-answering`, `reinforcement-learning`, `robotics`, `sentence-similarity`, `summarization`, `table-question-answering`, `tabular-classification`, `tabular-regression`, `text-classification`, `text-generation`, `text-ranking`, `text-to-3d`, `text-to-audio`, `text-to-image`, `text-to-speech`, `text-to-video`, `time-series-forecasting`, `token-classification`, `translation`, `unconditional-image-generation`, `video-classification`, `video-text-to-text`, `video-to-video`, `visual-document-retrieval`, `visual-question-answering`, `voice-activity-detection`, `zero-shot-classification`, `zero-shot-image-classification`, `zero-shot-object-detection`

Accepted aliases: `llm`, `textgen`, `causal-lm` → `text-generation`; `txt2img`, `text2image`, `image-generation` → `text-to-image`; `vlm`, `vision-language`, `multimodal-chat` → `image-text-to-text`; `asr`, `speech-to-text`, `speech2text`, `transcription` → `automatic-speech-recognition`; `embeddings`, `embedding` → `feature-extraction`; `qa` → `question-answering`; `tts`, `speech-synthesis` → `text-to-speech`; `ner`, `named-entity-recognition` → `token-classification`; `sentiment-analysis` → `text-classification`; `masked-lm` → `fill-mask`; `summarisation` → `summarization`.

#### Dataset task categories (`taskCategories`)

The dataset index uses its own 52-value list, mostly the same words: `question-answering`, `text-generation`, `text-classification`, `token-classification`, `summarization`, `translation`, `automatic-speech-recognition`, `audio-classification`, `image-classification`, `image-to-text`, `text-to-image`, `text-retrieval`, `text-ranking`, `table-question-answering`, `table-to-text`, `tabular-classification`, `tabular-regression`, `multiple-choice`, `feature-extraction`, `sentence-similarity`, `object-detection`, `image-segmentation`, `depth-estimation`, `video-classification`, `video-text-to-text`, `visual-question-answering`, `visual-document-retrieval`, `zero-shot-classification`, `zero-shot-image-classification`, `zero-shot-object-detection`, `reinforcement-learning`, `robotics`, `time-series-forecasting`, `graph-ml`, `mask-generation`, `any-to-any`, `text-to-3d`, `image-to-3d`, `text-to-audio`, `text-to-speech`, `text-to-video`, `image-to-image`, `image-to-video`, `image-text-to-text` and a few more. The task aliases above work here too.

#### Libraries

Models: `transformers`, `pytorch`, `tf`, `jax`, `safetensors`, `gguf`, `diffusers`, `peft`, `sentence-transformers`, `timm`, `onnx`, `openvino`, `mlx`, `transformers.js`, `keras`, `tf-keras`, `sklearn`, `spacy`, `flair`, `nemo`, `espnet`, `speechbrain`, `fastai`, `setfit`, `coreml`, `tflite`, `executorch`, `stable-baselines3`, `ml-agents`, `llamafile`, `paddlepaddle`, `open_clip`, `fasttext` and about 20 more.
Datasets: `datasets`, `pandas`, `polars`, `dask`, `mlcroissant`, `webdataset`, `distilabel`, `argilla`, `fiftyone`, `lerobot`, `lance` and a few newer ones.
Accepted aliases: `llama.cpp`, `llamacpp`, `ollama` → `gguf`; `scikit-learn`, `scikit` → `sklearn`; `sbert` → `sentence-transformers`; `hf-transformers`, `huggingface-transformers` → `transformers`; `core-ml` → `coreml`; `open-vino` → `openvino`; `hf-datasets` → `datasets`.

#### Licences

82 ids. The frequent ones: `apache-2.0`, `mit`, `other`, `openrail`, `openrail++`, `creativeml-openrail-m`, `cc-by-4.0`, `cc-by-sa-4.0`, `cc-by-nc-4.0`, `cc-by-nc-sa-4.0`, `cc-by-nc-nd-4.0`, `cc0-1.0`, `cc`, `gemma`, `llama2`, `llama3`, `llama3.1`, `llama3.2`, `llama3.3`, `llama4`, `bsd-3-clause`, `bsd-2-clause`, `bsd`, `gpl-3.0`, `gpl-2.0`, `agpl-3.0`, `afl-3.0`, `artistic-2.0`, `unlicense`, `wtfpl`, `odc-by`, `cdla-permissive-2.0`, `bigscience-bloom-rail-1.0`, `bigcode-openrail-m`, `c-uda`.
Accepted aliases: `apache`, `apache2`, `apache-2` → `apache-2.0`; `mit-license` → `mit`; `cc0`, `public-domain` → `cc0-1.0`; `bsd3` → `bsd-3-clause`; `gpl3` → `gpl-3.0`; `open-rail` → `openrail`.

#### Dataset facets for `tagFilters`

| Group | Values |
|---|---|
| `size_categories:` | `n<1K`, `1K<n<10K`, `10K<n<100K`, `100K<n<1M`, `1M<n<10M`, `10M<n<100M`, `100M<n<1B`, `1B<n<10B`, `10B<n<100B`, `100B<n<1T`, `n>1T` |
| `modality:` | `text`, `image`, `audio`, `video`, `tabular`, `timeseries`, `geospatial`, `document`, `3d` |
| `format:` | `parquet`, `json`, `csv`, `text`, `arrow`, `webdataset`, `imagefolder`, `audiofolder`, `optimized-parquet`, `agent-traces` |
| `language:` | any Hub language code (`language:en`); on the **model** index the same filter is the bare code (`en`) — the actor writes the right form for the index you chose |
| `library:` | dataset libraries, e.g. `library:polars` |
| other | `arxiv:2505.09388`, `base_model:<id>`, `region:us`, `conversational`, `synthetic`, `code`, `medical`, `legal`, `finance` |

#### Sort keys

| Value | Order | Notes |
|---|---|---|
| `downloads` | 30-day downloads | The Hub's `downloads` is a rolling 30-day figure, not a total |
| `likes` | all-time likes | |
| `trendingScore` | the Hub's short-term ranking | Moves through the day |
| `createdAt` | first publication | The only key that also accepts `asc` |
| `lastModified` | last commit | |

All-time downloads are written in every row but cannot be sorted on: the Hub answers HTTP 400 for that order, and for `asc` with anything but `createdAt`.

### Examples

**Trending repositories right now**

```json
{ "repoType": "models", "sort": "trendingScore", "sortDirection": "desc", "maxItems": 25 }
```

**The most used text-generation models**

```json
{ "repoType": "models", "pipelineTag": "text-generation", "sort": "downloads", "sortDirection": "desc", "maxItems": 25 }
```

**Apache 2.0 weights for a product review**

```json
{ "repoType": "models", "licenses": ["apache-2.0"], "sort": "likes", "sortDirection": "desc", "maxItems": 25 }
```

**Small language models that fit a laptop**

```json
{ "repoType": "models", "pipelineTag": "text-generation", "maxParametersMillions": 1000, "sort": "downloads", "maxItems": 20 }
```

**Everything one organisation ships, trimmed to seven columns**

```json
{ "repoType": "models", "authors": ["google"], "sort": "downloads", "includeModelConfig": true, "maxItems": 20,
  "fields": ["id", "author", "downloads30Days", "likes", "parameterCount", "license", "gatedMode"] }
```

**Question-answering datasets, most used first**

```json
{ "repoType": "datasets", "taskCategories": ["question-answering"], "sort": "downloads", "sortDirection": "desc", "maxItems": 25 }
```

**English corpora for text generation**

```json
{ "repoType": "datasets", "taskCategories": ["text-generation"], "languages": ["en"], "sort": "downloads", "maxItems": 20 }
```

**A keyword watch list for a schedule**

```json
{ "repoType": "models", "search": "llama", "sort": "lastModified", "sinceHours": 168, "onlyNew": true, "maxItems": 20 }
```

### Output

One row per repository. A real row from a cloud run (`sort: trendingScore`, long arrays trimmed with "…"):

```json
{
  "id": "deepseek-ai/DeepSeek-V4.1-Flash-1017",
  "repoType": "model",
  "name": "DeepSeek-V4.1-Flash-1017",
  "author": "deepseek-ai",
  "url": "https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017",
  "found": true,
  "fetchedAt": "2026-10-21T21:13:07.622Z",
  "pipelineTag": "image-text-to-text",
  "libraryName": "transformers",
  "license": "mit",
  "languages": [],
  "tags": [
    "transformers",
    "safetensors",
    "deepseek_v41",
    "text-generation",
    "image-text-to-text",
    "…"
  ],
  "downloads30Days": 42122,
  "downloadsAllTime": 42122,
  "likes": 2143,
  "trendingScore": 1897,
  "gated": false,
  "gatedMode": "open",
  "parameterCount": 763205315794,
  "parameterPrecisions": [
    "BF16",
    "F32",
    "F8_E4M3",
    "I8"
  ],
  "baseModels": [],
  "createdAt": "2026-10-17T02:40:38.000Z",
  "lastModified": "2026-10-17T05:46:55.000Z",
  "daysSinceUpdate": 4.6,
  "sha": null
}
```

| Field | Type | When it is filled |
|---|---|---|
| `id` | string | Always — `owner/name` as the Hub writes it |
| `repoType` | string | Always — `model` or `dataset` |
| `name` | string | Always — the part after the owner |
| `author` | string | Always — the owner handle |
| `url` | string | Always — the repository page on the Hub |
| `description` | string | Datasets: the first 400 characters of the card, plain text |
| `prettyName` | string | Datasets with `includeCardMetadata`, when the card declares one |
| `pipelineTag` | string | Models, when the owner declared a task |
| `libraryName` | string | Models, when the owner declared a library |
| `license` | string | When the card header or a `license:` tag has one |
| `languages` | string\[] | When the owner declared languages (often empty) |
| `taskCategories` | string\[] | Datasets, from the card and the tags |
| `tags` | string\[] | Always — every Hub tag of the repository |
| `sizeCategory` | string | Datasets, e.g. `1K<n<10K` |
| `modalities` | string\[] | Datasets, e.g. `text`, `image` |
| `formats` | string\[] | Datasets, e.g. `parquet` |
| `downloads30Days` | number | Always for list rows — downloads of the last 30 days |
| `downloadsAllTime` | number | List rows; the per-repository record does not carry it |
| `likes` | number | Always |
| `trendingScore` | number | List rows |
| `gated` | boolean | Always |
| `gatedMode` | string | Always — `open`, `auto` (instant click-through) or `manual` (owner approval) |
| `parameterCount` | number | Models with `includeParameterCount`, when the Hub publishes a safetensors weight index |
| `parameterPrecisions` | string\[] | Same — e.g. `["BF16"]`, `["F32","I8"]` |
| `baseModels` | string\[] | Models with `includeCardMetadata`, when the card or the tags name one |
| `modelType` | string | Models with `includeModelConfig` |
| `architectures` | string\[] | Models with `includeModelConfig` |
| `repoSizeBytes` | number | Datasets always; models with `includeRepoDetails` |
| `fileCount` | number | With `includeRepoDetails` or an exact-id lookup |
| `spacesCount` | number | Same — how many Hub demos use the repository |
| `inferenceStatus` | string | Same — e.g. `warm`, `cold` |
| `createdAt` | string | Always — ISO 8601 UTC |
| `lastModified` | string | Always — last commit, ISO 8601 UTC |
| `daysSinceUpdate` | number | Always — days between the last commit and the run |
| `sha` | string | With `includeRepoDetails` or an exact-id lookup — the commit hash |
| `found` | boolean | Always — `false` on a marker row for an id the Hub will not serve |
| `notFoundReason` | string | Marker rows only |
| `fetchedAt` | string | Always — when the run read the Hub, ISO 8601 UTC |

Dataset views: **Repositories** (overview), **Size and lineage**, **New and recently changed**, **Datasets**.

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~huggingface-hub-models/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"repoType":"models","pipelineTag":"text-generation","sort":"downloads","maxItems":25}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/huggingface-hub-models').call({ repoType: 'models', licenses: ['apache-2.0'], sort: 'likes', maxItems: 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/huggingface-hub-models").call(run_input={"repoType": "datasets", "taskCategories": ["question-answering"], "maxItems": 25})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/huggingface-hub-models` tool with the same JSON input. One row per repository; use `fields` to trim the row to what the model needs (`["id","pipelineTag","parameterCount","downloads30Days","license"]` keeps the answer short).

### Pricing

Pay per event: **$0.001 per run start + $0.002 per dataset row**. Every run pays the start event, also a run that writes nothing; every row written to the dataset is paid, marker rows with `found: false` included. On a paid Apify plan the row price falls with the Store tier (Bronze $0.0018, Silver $0.0016, Gold and above $0.0014); the start event stays $0.001.

Worked examples at the full price:

- the default run, 25 rows: $0.001 + 25 × $0.002 = **$0.051**
- a typical shortlist, 50 rows: $0.001 + 50 × $0.002 = **$0.101**
- a full catalogue page of 500 rows: $0.001 + 500 × $0.002 = **$1.001**

Rows dropped by `minDownloads`, `minLikes` or the parameter band are never written and never billed — they only cost the requests that read them. The run also stops at the "Maximum cost per run" you set when starting it: it then ends successfully, keeps every row you already paid for and says so in its status ("Stopped at your spending limit: N rows delivered").

### Limits & FAQ

- **Speed.** Measured in the Apify cloud on 2026-10-21. A list page of up to 100 repositories costs one request, so the default 25-row run takes about 4 seconds and a 1,000-row run about 15 seconds (ten pages at one request per second). With `includeRepoDetails` every row costs one more request: 300 models with their own records took 306 seconds (304 requests, 59.5 rows per minute), and a run given only 60 seconds wrote 43 complete rows and stopped itself. So the default run timeout of 15 minutes covers the largest input the schema allows (1,000 rows) in list mode, while in detail mode about 750 rows fit; past that the run stops before the timeout, keeps and bills only the rows it finished, and says so in its status.
- **The Hub's rate limit.** The API allows 500 requests per 5-minute window per IP address for anonymous callers (1,000 with a free account's token). This actor paces itself at 1 request per second — 300 per window — reads the `RateLimit` header the Hub returns and slows down further when the window runs low. Apify servers share their IP addresses between customers, so a run can meet a window that other traffic has already used: the actor then waits and continues more slowly, and a run that is refused from its very first request stops at once with a message telling you to start again in a few minutes or to add your own token (`hfToken`).
- **The run stops before its timeout, with the rows kept.** When the run timeout or your maximum cost per run is reached, the actor stops starting new work, keeps every row already written and ends successfully with "Stopped before the run timeout: N rows saved" or "Stopped at your spending limit: N rows delivered".
- **`downloads` is a 30-day figure.** The Hub's `downloads` counts the last 30 days; `downloadsAllTime` is the total. Only the 30-day figure can be sorted on, and the trending score moves through the day, so two runs hours apart legitimately differ.
- **Parameter counts are not universal.** They come from the safetensors weight index the Hub publishes. A repository shipped only as GGUF, as pickled PyTorch or as external files has `parameterCount: null` and drops out of a parameter band; the run status says how many rows were dropped for a missing count.
- **Owner-declared metadata is often missing.** Languages, licences and task tags exist only where the owner wrote them into the card. A language filter therefore finds fewer repositories than exist, especially on the model index.
- **A hidden repository answers 401, not 404.** Deleted, renamed, private and misspelt ids are indistinguishable from outside, so an exact-id lookup that fails is written as one row with `found: false` and a reason — never a failed run.
- **Several filter values cost several requests.** Repeated Hub filters are ANDed, so each licence, language, task category and owner needs its own request per page; the rows of the combinations are merged in the order you listed them, each combination in the order you chose. A 25-owner watch list makes at least 25 requests.
- **Gated repositories** are listed with their metadata; their files are never read. No model or dataset files are downloaded at all — only metadata.
- **Private repositories** are invisible: the actor reads the Hub without a login, and a token you supply raises the quota only.
- Questions or problems: open an issue on the Issues tab of this actor.

***

Made by **Yadroo**. Sibling actors: [openalex-works](https://apify.com/yadroo/openalex-works), [arxiv-papers](https://apify.com/yadroo/arxiv-papers), [github-repo-intel](https://apify.com/yadroo/github-repo-intel), [pypi-package-intel](https://apify.com/yadroo/pypi-package-intel), [npm-package-intel](https://apify.com/yadroo/npm-package-intel).

# Actor input Schema

## `repoType` (type: `string`):

One run reads one kind of repository. `models` uses the Hub's model index (task tag, library, parameter count); `datasets` uses the dataset index (task categories, size band, stored bytes, a short card description). The two indexes answer with different fields and different tag spellings, so run the actor twice, or keep two tasks, when you need both. Every row names its own kind in `repoType`.

## `search` (type: `string`):

Free-text term handed to the Hub's own search, which matches it against the repository id and owner (`qwen`, `whisper`, `embedding`, `medical`). It travels exactly as you type it - the Hub decides what matches, so a partial word works and no correction is applied here. Leave it empty to list everything the filters allow, in the order you chose.

## `repoIds` (type: `array`):

Look up named repositories instead of searching: one `owner/name` per line (`Qwen/Qwen3-0.6B`, `openai/gpt-oss-20b`, `cais/mmlu` for datasets). Case and surrounding spaces are ignored and a full Hub URL is reduced to the id. Each id is read from its own metadata endpoint, so these rows carry the detail columns even with the detail switch off. An id the Hub does not serve anonymously - deleted, renamed, private or misspelt - comes back as one row with `found: false`, because the Hub answers 401 for every repository it will not show and those cases cannot be told apart from outside. The filters below still apply to the rows.

## `pipelineTag` (type: `string`):

Keep only models whose owner declared this task. Pick a value from the list or type another one: the Hub published 59 task ids on 2026-10-21 and keeps adding them, so this field accepts any of them. Case, spaces and the usual separators are read the same (`text to image`, `Text-To-Image`). A value that is not a Hub task id stops the run and names the closest ids instead of returning a wider list. Ignored for datasets - those use the task-categories field.

## `library` (type: `string`):

Keep only repositories carrying this library or weight format - the short answer to "what can my stack actually load": `gguf` for llama.cpp-style local builds, `transformers` for the Python pipeline, `diffusers` for image models, `mlx` for Apple silicon, `onnx` or `openvino` for runtime exports. It is sent as a Hub tag, which matches exactly, and it is checked against the vocabulary of the kind you chose - the dataset index has its own short list (`datasets`, `pandas`, `polars`, `mlcroissant`, `webdataset` and a few more), the model index a long one. Case and spaces are ignored; a value neither index knows stops the run with the closest ids named.

## `licenses` (type: `array`):

Keep only repositories published under one of these licence ids, one per line as the Hub writes them: `apache-2.0`, `mit`, `cc-by-4.0`, `cc-by-nc-4.0`, `cc-by-sa-4.0`, `openrail`, `gemma`, `llama3.1`, `llama3.3`, `odc-by`, `other`. The `license:` prefix may be written or left out. Each licence is asked for in its own request and the answers are merged, so five licences cost five requests per page. An id the Hub does not know stops the run with the closest ones named; the README lists the frequent ones.

## `languages` (type: `array`):

Keep only repositories whose owner declared one of these languages, one code per line (`en`, `ru`, `kk`, `de`, `zh`, `multilingual`). The Hub carries thousands of language tags - more than 5,000 on models alone - so codes are lower-cased and passed through unchanged with no correction and no suggestions; a code nothing carries simply yields no rows and the run status says which filter matched nothing. Models and datasets spell the language tag differently and the actor sends the right form for the kind you chose. Many repositories declare no language at all and are invisible to this filter, so leave it empty when coverage matters more than precision.

## `taskCategories` (type: `array`):

Keep only datasets tagged with one of these task categories, one per line (`question-answering`, `text-generation`, `text-classification`, `summarization`, `automatic-speech-recognition`, `image-classification`, `translation`, `table-question-answering`). They share the vocabulary of the model tasks. One request per value, merged like the licences. Ignored for models.

## `tagFilters` (type: `array`):

Raw Hub tag filters, one per line, all of which a repository must carry - the escape hatch for filters this input does not name. Examples: `size_categories:1K<n<10K`, `modality:text`, `format:parquet`, `base_model:Qwen/Qwen3-0.6B`, `arxiv:2505.09388`, `conversational`. Tags travel unchanged; a tag nothing carries yields no rows, which the run status reports plainly.

## `authors` (type: `array`):

Keep only repositories owned by these users or organisations, one per line (`google`, `Qwen`, `meta-llama`, `mistralai`, `openai`, `allenai`). The Hub matches an owner case-sensitively, so a name written in another case is looked up once on the Hub's own user or organisation record and re-queried in its canonical spelling, which the run status reports. Each owner costs one request per page, so a 25-owner watch list makes 25 requests per page. An owner with no public repositories of the chosen kind is named in the status.

## `minDownloads` (type: `integer`):

Drop repositories with fewer downloads in the last 30 days than this. The Hub has no such filter, so the actor applies it to the rows it has read: with a high threshold and a wide search it may read several pages before the row cap is reached, and the run stops when its time or cost budget is used up. Sorting by downloads makes the threshold cheap, because paging can stop at the first row below it.

## `minLikes` (type: `integer`):

Drop repositories with fewer likes than this. Applied by the actor in the same way as the download threshold.

## `minParametersMillions` (type: `integer`):

Keep only models with at least this many million parameters (`7000` = 7B). The count comes from the weight index the Hub publishes for safetensors repositories, so models shipped only as GGUF, as pickled PyTorch or as external files have no count: they carry `parameterCount: null` and drop out as soon as a bound is set. The run status reports how many rows were dropped for a missing count.

## `maxParametersMillions` (type: `integer`):

Keep only models with at most this many million parameters - the filter for "what fits on this GPU, laptop or phone" (`1000` = up to 1B, `8000` = up to 8B). Same source and same blind spot as the minimum above; set both for a band.

## `gatedAccess` (type: `string`):

A gated repository shows its metadata to everyone but needs an accepted licence or an approved request before its files can be fetched. `open` keeps only repositories whose files anyone can download - useful when the result feeds an automated download step. Every row reports `gated` and `gatedMode` (`open`, `auto` for an instant click-through, `manual` for owner approval) whatever you choose here.

## `createdSince` (type: `string`):

Keep only repositories first published on or after this date - the filter behind "what is new". Combined with sorting by creation date, paging stops at the first repository older than the date, so a narrow window is cheap.

## `updatedSince` (type: `string`):

Keep only repositories whose last commit is on or after this date. A repository can be years old and still have been changed yesterday, so this is the field for "maintained", while the one above is for "newly published".

## `sinceHours` (type: `integer`):

Rolling window instead of a fixed date: keep only repositories whose last commit is newer than this many hours before the run started, counted in UTC (`24` for today, `168` for a week). Made for a schedule - the window moves with every run, so the task text never needs editing. Applied together with the dates above when both are set.

## `onlyNew` (type: `boolean`):

Remember the repository ids and commit hashes this run writes, and on the next run of the same actor or task write only rows that are new or whose commit has changed - a watch list that reports releases and updates instead of repeating the whole catalogue. The first run writes everything. The memory belongs to the actor or task, so two tasks watching two owners never mix.

## `includeParameterCount` (type: `boolean`):

On (default): model rows carry `parameterCount` and `parameterPrecisions` (`BF16`, `F32`, `I8` ...) from the Hub's weight index. It travels inside the same list response, so it costs no extra request. Off: both columns are left out.

## `includeCardMetadata` (type: `boolean`):

On (default): the card header is read along with the list, filling `license`, `baseModels` (what a fine-tune was built on) and the dataset `prettyName`. Also free - the same response carries it. Off: the licence is still derived from the repository's tags where one is present.

## `includeModelConfig` (type: `boolean`):

On: model rows get `modelType` (`qwen3`, `llama`, `mistral` ...) and `architectures` from the repository's configuration file. The Hub sends that whole file, chat templates included, so the response grows a lot while only these two columns are kept - off by default for that reason, though it needs no extra request.

## `includeRepoDetails` (type: `boolean`):

On: every row is completed from its own metadata endpoint, adding `fileCount`, `spacesCount` (how many Hub demos use it), `inferenceStatus`, `sha` and, for models, `repoSizeBytes`. That is one request per row on top of the list requests, so a 100-row run makes about 101 requests and takes roughly twice as long at the polite pace; the row cap and your maximum cost per run still hold. Off (default): only what the list response carries - dataset rows get their stored size there anyway. Rows looked up by exact id always carry these fields.

## `sort` (type: `string`):

The order the Hub returns, and therefore which rows the row cap keeps. `downloads` is the rolling 30-day figure, not an all-time total; `trendingScore` is the Hub's own short-term ranking and moves through the day. All-time downloads are reported in every row but cannot be sorted on - the Hub refuses that order.

## `sortDirection` (type: `string`):

`desc` answers "the biggest, the newest" and works with every sort key. `asc` is served by the Hub for the creation date only - the oldest repositories of an owner or of a task; asked for together with downloads, likes, trending score or the commit date it is refused before the first request, with a message naming the two ways forward, because the Hub itself answers HTTP 400 for those orders.

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

Hard cap on the rows this run writes, and so on what it costs. The Hub serves up to 100 repositories per request, so 25 rows is one request and 1,000 rows ten. Rows dropped by the actor's own thresholds (downloads, likes, parameters) do not count against the cap but do cost requests. The run also stops at the maximum cost per run you set on the platform and says so in its status.

## `fields` (type: `array`):

Keep only the named columns, in this order - for example `id, pipelineTag, parameterCount, downloads30Days`. Empty = every column. `id`, `repoType`, `found`, `url` and `fetchedAt` are always written; name one of them here and it moves to the position you gave it. An unknown name is reported in the run status rather than silently ignored.

## `hfToken` (type: `string`):

A read-only token of your own, if you have one. Without it the Hub allows 500 API requests per five minutes per IP address, and Apify's servers share their addresses between users, so a long run can meet that ceiling; a free account's token raises the quota to 1,000 and counts it against you alone. The token is sent to the Hub only and never written to the dataset, the log or SUMMARY. It does not unlock gated or private repositories here - only public metadata is read.

## Actor input object example

```json
{
  "repoType": "models",
  "search": "qwen",
  "gatedAccess": "any",
  "onlyNew": false,
  "includeParameterCount": true,
  "includeCardMetadata": true,
  "includeModelConfig": false,
  "includeRepoDetails": false,
  "sort": "downloads",
  "sortDirection": "desc",
  "maxItems": 25
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "search": "qwen"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/huggingface-hub-models").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 = { "search": "qwen" }

# Run the Actor and wait for it to finish
run = client.actor("yadroo/huggingface-hub-models").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 '{
  "search": "qwen"
}' |
apify call yadroo/huggingface-hub-models --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/huggingface-hub-models"
        }
    }
}
```

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/VXgV12q1mj9SlPoTu/builds/6CeFdeOmmCQBTdYWg/openapi.json