# Hugging Face Trending Models, Datasets & Spaces Tracker (`gochujang/huggingface-model-tracker`) Actor

Track trending and top-downloaded Hugging Face models, datasets, and Spaces. Filter by task (text-generation, image-classification), author/org (meta-llama, microsoft), or keyword. Returns downloads, likes, trending score, license, tags, gated status. Optional detail enrichment. No API key needed.

- **URL**: https://apify.com/gochujang/huggingface-model-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

### What does HuggingFace Model Tracker do?

**HuggingFace Model Tracker** is an Apify Actor that monitors **trending and top-downloaded AI models, datasets, and Spaces** on the Hugging Face Hub in real time — no API key required. It pulls live data from the public HF Hub API and returns structured records for every item including download counts, likes, trending scores, license, tags, gated status, and direct Hub URLs. Whether you are tracking the latest **open source LLM releases** from Meta, Mistral, Google, or Microsoft, or monitoring fast-rising research models before they go viral, this Actor delivers a clean feed of **AI model releases** on demand.

### Why use HuggingFace Model Tracker?

The Hugging Face Hub publishes hundreds of new models every day. Manually tracking what is trending across **text-generation, image-to-text, speech recognition**, and dozens of other tasks is impractical without automation. Key business use cases:

- **LLM release monitoring** — get instant alerts when major labs (Meta, Mistral, Google DeepMind, Microsoft) push new models to the Hub. Filter by `authorFilter` to watch specific organizations.
- **Research trend detection** — track fast-rising models by `trending_score` before they accumulate mass downloads. Discover breakout architectures and techniques weeks before the broader community notices.
- **Competitive intelligence** — compare download counts, likes, and trending velocity across competing model families (e.g. Llama vs. Mistral vs. Gemma) for product strategy decisions.
- **Dataset discovery for fine-tuning** — switch to `mode: datasets` to find the most popular training and evaluation datasets for your target task, sorted by trending or downloads.
- **Space popularity tracking** — monitor `mode: spaces` to discover popular Gradio and Streamlit demos, identify deployment patterns, and find community tools gaining traction.

### How to use HuggingFace Model Tracker

1. **Open the Actor** on Apify Store and click **Try for free**.
2. **Choose a mode** — `models`, `datasets`, or `spaces` (default: `models`).
3. **Set a sort order** — `trending` for what is hot right now, `downloads` for most-used, `likes` for community favorites, or `lastModified` for recent activity.
4. **Filter by task** (optional) — enter a pipeline task tag such as `text-generation`, `image-classification`, `text-to-image`, or `automatic-speech-recognition`.
5. **Filter by author/org** (optional) — enter an org slug such as `meta-llama`, `microsoft`, `google`, or `mistralai`.
6. **Set the item limit** — 1 to 500. Default is 50.
7. **Run and export** — results appear in the dataset as flat JSON records, exportable as JSON, CSV, or XLSX.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `models` | What to fetch: `models`, `datasets`, or `spaces` |
| `sortBy` | string | `trending` | Sort order: `trending`, `downloads`, `likes`, `lastModified` |
| `limit` | integer | `50` | **Number of items to fetch** (1–500) |
| `search` | string | — | Keyword filter applied to name, description, and tags |
| `taskFilter` | string | — | Pipeline task tag: `text-generation`, `image-classification`, `question-answering`, `text-to-image`, `automatic-speech-recognition`, etc. |
| `authorFilter` | string | — | Filter by org or user: `meta-llama`, `microsoft`, `google`, `mistralai`, `stabilityai`, etc. |
| `includeDetails` | boolean | `false` | Fetch full model card + file list per item (models only; increases PPE charges) |

**Example — top 100 trending text-generation models:**

```json
{
  "mode": "models",
  "sortBy": "trending",
  "limit": 100,
  "taskFilter": "text-generation"
}
```

**Example — monitor Meta's latest model releases:**

```json
{
  "mode": "models",
  "sortBy": "lastModified",
  "limit": 20,
  "authorFilter": "meta-llama"
}
```

### Output

```json
[
  {
    "model_id": "meta-llama/Llama-3.1-8B",
    "author": "meta-llama",
    "name": "Llama-3.1-8B",
    "task": "text-generation",
    "downloads": 12345678,
    "likes": 5678,
    "trending_score": 99.5,
    "tags": ["llm", "pytorch", "transformers"],
    "license": "llama3.1",
    "last_modified": "2026-08-20T18:00:00.000Z",
    "created_at": "2024-07-18T00:00:00.000Z",
    "private": false,
    "gated": false,
    "hf_url": "https://huggingface.co/meta-llama/Llama-3.1-8B",
    "rank": 1,
    "mode": "models",
    "fetched_at": "2026-09-02T09:00:00.000000+00:00"
  },
  {
    "model_id": "mistralai/Mistral-7B-Instruct-v0.3",
    "author": "mistralai",
    "name": "Mistral-7B-Instruct-v0.3",
    "task": "text-generation",
    "downloads": 8901234,
    "likes": 3412,
    "trending_score": 87.2,
    "tags": ["llm", "pytorch", "transformers", "mistral"],
    "license": "apache-2.0",
    "last_modified": "2026-08-18T10:00:00.000Z",
    "created_at": "2024-05-22T00:00:00.000Z",
    "private": false,
    "gated": false,
    "hf_url": "https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.3",
    "rank": 2,
    "mode": "models",
    "fetched_at": "2026-09-02T09:00:00.000000+00:00"
  }
]
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `model_id` | string | Full Hub identifier (`author/model-name`) |
| `author` | string | Organization or user that published the model |
| `name` | string | Short model name |
| `task` | string | **Pipeline task** (e.g. `text-generation`, `image-classification`) |
| `downloads` | integer | **Total download count** (all time) |
| `likes` | integer | Number of community likes |
| `trending_score` | float | HF internal **trending score** (higher = more trending; not available for all items) |
| `tags` | array | Associated tags (frameworks, domains, languages) |
| `license` | string | License identifier (e.g. `apache-2.0`, `mit`, `llama3.1`) |
| `last_modified` | string | ISO 8601 timestamp of last Hub update |
| `created_at` | string | ISO 8601 timestamp of initial upload |
| `private` | boolean | `true` if the model is private |
| `gated` | boolean/string | `false`, `true`, `"auto"`, or `"manual"` — indicates **access control** level |
| `hf_url` | string | Direct **Hugging Face Hub URL** for the item |
| `rank` | integer | Position in the returned list (1 = top result) |
| `mode` | string | Which endpoint was queried: `models`, `datasets`, or `spaces` |
| `fetched_at` | string | ISO 8601 UTC timestamp of this Actor run |

### Cost estimation

This Actor uses **Pay-Per-Event (PPE)** pricing — you pay only for items actually fetched.

| Event | Price | Notes |
|-------|-------|-------|
| Actor start | $0.005 | Charged once per run |
| Per item fetched | $0.001 | Per model, dataset, or space record |

| Typical run | Items | Estimated cost |
|-------------|-------|----------------|
| 50 trending models (default) | 50 | **~$0.055** |
| 100 models | 100 | ~$0.105 |
| 500 models (full feed) | 500 | ~$0.505 |
| Daily monitor, 50 models/day × 30 days | 1,500 | ~$1.51/month |

### FAQ

**Does this Actor require a Hugging Face account or API token?**
No. It uses the public [Hugging Face Hub API](https://huggingface.co/docs/hub/api) endpoints (`/api/models`, `/api/datasets`, `/api/spaces`), which are freely accessible without authentication. Rate limits are handled automatically with retry logic.

**What is `trending_score` and how is it calculated?**
`trending_score` is a Hugging Face internal metric that measures how rapidly a model is gaining downloads and likes relative to its historical baseline. The exact formula is proprietary to HF. Not all items expose this field — expect it to be `null` for some models.

**Can I track new model releases from a specific organization automatically?**
Yes — schedule this Actor to run daily with `sortBy: "lastModified"` and your `authorFilter` set to the organization you want to watch (e.g. `meta-llama`, `google`, `mistralai`). Pair it with an Apify webhook to send new results to Slack, email, or your own API the moment a new model is detected.

***

*Disclaimer: Data is fetched from the public Hugging Face Hub API. Download counts, likes, and trending scores reflect the state of the Hub at the time of the Actor run and may change rapidly. `trending_score` is a Hugging Face internal metric and is not exposed for all items. This Actor has no affiliation with Hugging Face, Inc.*

***

### Related actors

- [AI Model Benchmark Tracker](https://apify.com/gochujang/ai-model-benchmark-tracker) — Benchmark scores for models discovered trending here
- [GitHub Trending Tracker](https://apify.com/gochujang/github-trending-tracker) — GitHub repos of open-source models for code and community activity
- [Semantic Scholar Papers](https://apify.com/gochujang/semantic-scholar-papers) — Research papers behind trending AI models on HuggingFace

### Feedback

If this actor powers your AI research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/huggingface-model-tracker#reviews)

# Actor input Schema

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

What to fetch: models, datasets, or spaces.

## `sortBy` (type: `string`):

Sort order for results.

## `limit` (type: `integer`):

Number of items to fetch (1–500). The actor fetches multiple pages of the Hugging Face API as needed.

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

Filter results by keyword (model name, description, tags).

## `taskFilter` (type: `string`):

Filter by ML task pipeline tag, e.g. text-generation, image-classification, question-answering, text-to-image, automatic-speech-recognition, translation, summarization, fill-mask, token-classification, sentence-similarity.

## `authorFilter` (type: `string`):

Filter by Hugging Face user or org handle, e.g. meta-llama, microsoft, google, mistralai.

## `includeDetails` (type: `boolean`):

If true, fetches the full model detail endpoint for each item (adds model card, parameters, safetensors info). Increases run time and PPE charges.

## Actor input object example

```json
{
  "mode": "models",
  "sortBy": "trending",
  "limit": 50,
  "search": "",
  "taskFilter": "",
  "authorFilter": "",
  "includeDetails": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "mode": "models",
    "sortBy": "trending",
    "limit": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/huggingface-model-tracker").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": "models",
    "sortBy": "trending",
    "limit": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/huggingface-model-tracker").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": "models",
  "sortBy": "trending",
  "limit": 50
}' |
apify call gochujang/huggingface-model-tracker --silent --output-dataset

```

## MCP server setup

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

```

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/zBGzYdXKzayVlArKO/builds/jnsgckLK56fXSxehN/openapi.json