# Hugging Face Trending Models Scraper — Radar & Change Watch (`symmetrical_omelet_yit/huggingface-model-radar`) Actor

Discover public Hugging Face models by trending score, downloads, likes or update time. Export model links, declared licenses and access metadata. Compare named watchlists across runs. Visual report, JSON and CSV. No Hugging Face key, proxy or developer fee.

- **URL**: https://apify.com/symmetrical_omelet_yit/huggingface-model-radar.md
- **Developed by:** [Yigit Ibze](https://apify.com/symmetrical_omelet_yit) (community)
- **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?

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 Trending Models Scraper — Radar & Change Watch

Turn a public Hugging Face model list into a readable discovery report and a repeatable metadata snapshot. Find models in trending, download, like, creation or modification order, then save a named watchlist to review what changed at the next successful run.

Useful for a research shortlist, a newsletter source list or a recurring model discovery review. Every live row links to its source model page. This community Actor is independent of Hugging Face.

### Start with live data

Click **Start** with the default input. It collects up to 20 public models in Hugging Face trending order. No Hugging Face token, proxy, AI key or paid source Actor is needed.

```json
{
  "maxResults": 20,
  "sort": "trendingScore",
  "demoMode": false
}
```

Open **Visual model radar** after the run, or use the default dataset, JSON report and CSV snapshot. The report includes source time, query, coverage warnings and comparison status.

### Inputs

| Input | Default | Meaning |
| --- | --- | --- |
| `maxResults` | `20` | Up to 100 models from a bounded query. |
| `sort` | `trendingScore` | Descending `trendingScore`, `downloads`, `likes`, `lastModified` or `createdAt`. |
| `task` | blank | Optional exact Hub pipeline tag, such as `text-generation`. |
| `search` | blank | Optional server-side text search within model IDs. |
| `reportName` | `AI model radar` | Display name, 1–80 characters. |
| `watchlistName` | blank | Optional persistent comparison name, up to 80 characters. |
| `demoMode` | `false` | Five fictional offline rows; no live collection or saved history. |

Task tags are limited to 80 characters and search to 100. Filters can return zero models. This version covers models only, with no separate author filter or exact-repository inventory mode.

### Compare a named watchlist

Run the same input twice, using a stable watchlist name:

```json
{
  "maxResults": 20,
  "sort": "trendingScore",
  "task": "text-generation",
  "watchlistName": "weekly-text-generation",
  "reportName": "Text generation radar"
}
```

The first live run establishes a baseline. A later comparable run records models newly present in the returned results, changes in position and metrics, and observed changes to revision SHA, declared license IDs, access setting, task or library. Unknown fields remain unknown. A missing declaration does not establish unchanged access or license facts.

History is stored in a named Apify key-value store. Keep one run at a time per watchlist. Changing sort, task, search or result limit starts a new baseline. Failed or invalid collections do not advance it; incomplete selections suppress history advancement. Demo runs never write history. Comparisons cover saved observations, not every intervening source change.

### Outputs

| Output | Contents |
| --- | --- |
| Default dataset | One normalized model observation per row. |
| `REPORT_HTML` | Standalone visual report with model links, metrics, change review and limitations. |
| `REPORT_JSON` | Rows, query, summary, warnings, history status and models absent from current results. |
| `MODELS_CSV` | Spreadsheet-friendly model snapshot with guarded formula-like text. |

Rows include `modelId`, `modelUrl`, `sourcePosition`, `task`, `library`, `licenseIds`, `gated`, `revisionSha`, `downloads30d`, `likes`, `trendingScore`, `createdAt`, `lastModified`, `observedAt`, `change`, prior position, metric differences and `metadataChanges`. Missing metrics are `null`; a real zero stays zero. JSON preserves structured license and change arrays.

### Read the signals correctly

- Position is rank within the current bounded query, not a global quality or performance ranking. The Actor preserves source order and does not invent a trending-score formula or time window.
- `downloads30d` is Hugging Face's rolling 30-day request-count metric. It is not installs or unique users. Its snapshot difference can be negative and is not newly acquired downloads. [Download counting documentation](https://huggingface.co/docs/hub/models-download-stats).
- A revision SHA or modification time can change after a repository edit. It does not prove new weights or a model release.
- License IDs are publisher declarations, not legal clearance or proof of suitability. Review the model page and its actual terms before use. [Model-card metadata](https://huggingface.co/docs/hub/model-cards).
- A model absent from a later bounded result list has left that query's returned sample. It may still exist. This is not a deletion detector or complete Hub monitor.

### Scope and cost

The Actor reads public Hub API metadata only. It does not fetch weights, execute model code, call inference, collect private repositories or download model-card body text. It uses bounded public requests and reports source access failures explicitly; failures never silently become sample data. [Hub API reference](https://huggingface.co/docs/huggingface_hub/package_reference/hf_api#huggingface_hub.HfApi.list_models).

**Free beta: no developer fee. Standard Apify compute, storage and platform usage apply.** A run cap is a spending limit, not a price guarantee. For a small first run, use a $0.10 maximum total charge, 512 MB and a 300-second timeout. This Actor supports Limited permissions and does not require Standby mode or automatic restart.

For support, open an issue with a run URL, the query and the expected behavior. Remove credentials and private information before sharing logs.

# Actor input Schema

## `maxResults` (type: `integer`):

Return up to this many public models from one sorted Hub API query. Filters and source coverage may produce fewer results. This is a bounded snapshot, not a complete Hub inventory.

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

Descending source order. Hugging Face supplies the trending score; this Actor does not infer its formula, a growth rate or model quality. Repository modification can include metadata edits.

## `task` (type: `string`):

Optional exact pipeline tag, for example text-generation, text-to-image, automatic-speech-recognition or feature-extraction. Leave blank for all tasks.

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

Optional text contained in a model ID, for example Qwen or whisper. Uses the Hub model-ID search; it does not search model-card body text. No separate author filter in this version.

## `reportName` (type: `string`):

Name displayed on the visual and JSON reports. Renaming the report does not change the comparison scope.

## `watchlistName` (type: `string`):

Optional, for example weekly-model-discovery. Tracks models entering these results, position/metric differences and selected declared metadata changes. Changing sort, task, search or limit starts a fresh baseline. Leaving bounded results does not mean deletion. Blank disables history.

## `demoMode` (type: `boolean`):

Enable only for a fixed, clearly labelled fictional report. Sample names, counts and links are not live Hugging Face observations.

## Actor input object example

```json
{
  "maxResults": 20,
  "sort": "trendingScore",
  "task": "",
  "search": "",
  "reportName": "AI model radar",
  "watchlistName": "",
  "demoMode": false
}
```

# Actor output Schema

## `reportHtml` (type: `string`):

No description

## `models` (type: `string`):

No description

## `reportJson` (type: `string`):

No description

## `modelsCsv` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("symmetrical_omelet_yit/huggingface-model-radar").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 = {}

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

```

## MCP server setup

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

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/NlUTjc28jHiLwEqVy/builds/6VDp8uxhUgyr4BINM/openapi.json