# Hugging Face Model & Dataset Trend Tracker (`dsh-org/huggingface-model-dataset-tracker`) Actor

Track trending Hugging Face models and datasets by downloads, likes, and velocity. Filter by task, library, or tag. Monitor mode alerts you to newly trending entries. Built for ML engineers, DevRel, and AI researchers.

- **URL**: https://apify.com/dsh-org/huggingface-model-dataset-tracker.md
- **Developed by:** [DSH](https://apify.com/dsh-org) (community)
- **Categories:** AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Hugging Face Model & Dataset Trend Tracker

Track **trending Hugging Face models and datasets** — **downloads**, **likes**, and **velocity** — straight from the **official public Hugging Face Hub API**. No browser, no scraping tricks, **no API key required**. Filter by **task** (text-generation, text-to-image, automatic-speech-recognition…), **library** (transformers, diffusers, gguf…), or tag, and switch on **monitor mode** to get alerted the moment a new **LLM**, model, or dataset starts trending.

This is **AI-model trend intelligence**, not a static catalog dump: instead of "list every model," it answers *"what's gaining adoption on Hugging Face right now."* Built for **ML engineers**, **DevRel** and **LLM-ops** teams, **AI researchers**, and **data teams** who need to see what's rising across the open-model ecosystem. (Pairs with our **[Civitai Model & Prompt Trend Tracker](https://apify.com/dsh-org/ai-art-prompt-model-trend-tracker)** for the creative/AI-art side.)

### What you get

Both result types land in one dataset, each row tagged with `resultType` (`"model"` or `"dataset"`) so you can split them downstream.

#### Trending model fields

| Field | Description |
|---|---|
| `modelId`, `author`, `modelName` | Full repo id (`owner/name`), owner, and short name |
| `pipelineTag` | Canonical task, e.g. `text-generation`, `text-to-image` (may be `null` if untagged) |
| `libraryName` | Library/framework, e.g. `transformers`, `diffusers`, `gguf` |
| `tags` | All Hub tags on the repo |
| `downloads`, `likes` | Adoption metrics |
| `trendingScore` | Hugging Face's own trending signal (`null` if not exposed for the chosen sort) |
| `lastModified`, `createdAt` | ISO 8601 timestamps |
| `isPrivate`, `gated` | Visibility and gating (`false` / `"manual"` / `"auto"`) |
| `cardData` | Model-card front-matter: `license`, `language`, `datasets`, `baseModel` |
| `siblings` | Count of files in the repo (proxy for model size/complexity) |
| `config` | `config.json` architecture metadata — **only** when `includeConfig` is on |
| `modelUrl` | Direct Hugging Face link |
| `trendRank` | Position in the sorted results (1 = top) |
| `isNew` | `true` if new to trending since the last monitor run (`null` in snapshot mode) |
| `scrapedAt` | ISO 8601 timestamp of this run |

#### Trending dataset fields

| Field | Description |
|---|---|
| `datasetId`, `author`, `datasetName` | Full id (`owner/name`), owner, and short name |
| `tags` | All Hub tags |
| `downloads`, `likes` | Adoption metrics |
| `trendingScore` | Hugging Face trending signal (`null` if not exposed) |
| `lastModified`, `createdAt` | ISO 8601 timestamps |
| `isPrivate`, `gated` | Visibility and gating |
| `cardData` | Dataset-card front-matter: `license`, `language`, `size`, `taskCategories` |
| `datasetUrl` | Direct Hugging Face link |
| `trendRank`, `isNew`, `scrapedAt` | Trend + monitor metadata |

### Two data types — which to use

- **Trending models** (`dataType: "models"`, the default) — what models and LoRAs/checkpoints are gaining adoption. Track model releases, discover emerging architectures, and watch a task or library heat up.
- **Trending datasets** (`dataType: "datasets"`) — which training/eval datasets are rising. Discover new corpora and benchmarks before they're everywhere.
- **Both** (`dataType: "both"`) — run both in one pass; rows are tagged with `resultType`.

### Monitor mode — track new trends over time

Set `mode: "monitor"` and attach an Apify **Schedule** (daily or weekly):

- **First run** stores the current trending IDs and returns everything.
- **Later runs** return **only entries new to the trending list** since the previous run, each flagged `isNew: true`.
- If nothing new is trending, the run finishes cleanly with an **empty dataset** (not an error).

State is keyed per data type and sort (`state-models-trending`, `state-datasets-downloads`, …) and persisted in a **named Key-Value Store**, so it survives across scheduled runs. This is the *"alert me when a new model starts trending"* workflow — feed it into Slack, email, or a webhook via Apify integrations. Keep your other filters (task, library, tags) stable between scheduled runs so the delta stays meaningful.

### Input

The simplest input is **no input at all** — you get the top 100 trending models:

```json
{}
````

Trending **text-generation** models built with **transformers**, top 50:

```json
{
  "dataType": "models",
  "sort": "trending",
  "pipelineTag": "text-generation",
  "library": "transformers",
  "limit": 50
}
```

Monitor **new trending datasets** every day:

```json
{
  "dataType": "datasets",
  "mode": "monitor",
  "sort": "trending",
  "limit": 100
}
```

Most-downloaded **text-to-image** models this run, models and datasets together:

```json
{
  "dataType": "both",
  "sort": "downloads",
  "pipelineTag": "text-to-image",
  "limit": 100
}
```

| Input | Description |
|---|---|
| `dataType` | `models` (default), `datasets`, or `both` |
| `mode` | `snapshot` (default) or `monitor` (delta — new entries only) |
| `sort` | `trending` (default), `downloads`, `likes`, `lastModified`, `createdAt` |
| `direction` | `-1` descending (default, top first) or `1` ascending |
| `pipelineTag` | Task filter for models, e.g. `text-generation` (optional) |
| `library` | Library filter for models, e.g. `diffusers` (optional) |
| `search` | Free-text search over names, e.g. `"llama"` (optional) |
| `tags` | Restrict to Hub tags, e.g. `["multilingual"]` (optional) |
| `limit` | Max results per data type (default 100, up to 1000; paged automatically) |
| `includeConfig` | Attach each model's `config.json` (slower — one extra request per model) |
| `hfToken` | Optional Hugging Face token for higher rate limits / gated repos |

### Output examples

Trending model:

```json
{
  "resultType": "model",
  "modelId": "meta-llama/Llama-3.3-70B-Instruct",
  "author": "meta-llama",
  "modelName": "Llama-3.3-70B-Instruct",
  "pipelineTag": "text-generation",
  "libraryName": "transformers",
  "tags": ["text-generation", "transformers", "conversational", "llama"],
  "downloads": 1840320,
  "likes": 9421,
  "trendingScore": 152.4,
  "lastModified": "2026-06-15T09:31:00.000Z",
  "createdAt": "2026-05-30T09:12:00.000Z",
  "isPrivate": false,
  "gated": "manual",
  "cardData": {
    "license": "llama3.3",
    "language": ["en"],
    "datasets": null,
    "baseModel": ["meta-llama/Llama-3.1-70B"]
  },
  "siblings": 34,
  "modelUrl": "https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct",
  "trendRank": 1,
  "isNew": null,
  "scrapedAt": "2026-06-19T10:00:00.000Z"
}
```

Trending dataset:

```json
{
  "resultType": "dataset",
  "datasetId": "HuggingFaceFW/fineweb",
  "author": "HuggingFaceFW",
  "datasetName": "fineweb",
  "tags": ["task_categories:text-generation", "size_categories:10B<n<100B", "language:en"],
  "downloads": 512094,
  "likes": 2103,
  "trendingScore": 88.1,
  "lastModified": "2026-06-01T00:00:00.000Z",
  "createdAt": "2026-04-01T00:00:00.000Z",
  "isPrivate": false,
  "gated": false,
  "cardData": {
    "license": "odc-by",
    "language": ["en"],
    "size": "10B<n<100B",
    "taskCategories": ["text-generation"]
  },
  "datasetUrl": "https://huggingface.co/datasets/HuggingFaceFW/fineweb",
  "trendRank": 1,
  "isNew": null,
  "scrapedAt": "2026-06-19T10:00:00.000Z"
}
```

### Use cases

- **ML engineers** tracking which models are gaining real adoption before committing to one.
- **DevRel teams** monitoring ecosystem trends for their framework or library.
- **AI researchers** spotting emerging architectures, techniques, and base models.
- **LLM-ops teams** tracking model popularity to inform deployment and support decisions.
- **Data teams** discovering trending training and evaluation datasets.
- **AI newsletters, educators, and content creators** covering what's hot on Hugging Face each week.
- **RAG pipeline builders** tracking models and datasets worth ingesting.

### Limitations

- **`trending` is Hugging Face's own signal**, not just raw downloads — it blends recency and velocity. Use `sort: "downloads"` or `"likes"` if you want a pure popularity ranking.
- **Rate limits.** The public Hub API is generous but throttles heavy use. The Actor throttles requests and backs off on HTTP 429; increase `requestDelayMs`, or add an `hfToken`, if you page large limits.
- **Sparse metadata.** Not every repo declares a `pipelineTag`, `library`, or full card front-matter — those fields come back `null` rather than failing the run.
- **Gated/private repos** appear in listings with `gated`/`isPrivate` set, but their files aren't accessible without an authorized `hfToken`.
- **`includeConfig` is slower** — it adds one request per model to fetch `config.json`. Leave it off unless you need architecture details.

### Pricing (Pay-Per-Event)

This Actor uses Apify's **Pay-Per-Event** model — you pay only for what you pull, **from ~$4 per 1,000 results**:

| Event | When charged |
|---|---|
| Actor run start | Once per run |
| Trending model tracked | Per trending model returned (in monitor mode, only new-to-trending models) |
| Trending dataset tracked | Per trending dataset returned (in monitor mode, only new-to-trending datasets) |

No subscription, no rental. In monitor mode you're charged only for genuinely new trending entries — checking state is free.

### Use it from an AI agent (MCP)

This Actor is **MCP-ready**: run it as a tool from Claude, Cursor, or ChatGPT via Apify's MCP integration to give your agent live *"what's trending on Hugging Face"* data — trending models, datasets, and their metadata — on demand.

### FAQ

**Do I need a Hugging Face API key?** No. The public Hub API works without one. Add an optional `hfToken` only to raise rate limits or read gated/private repos you have access to.

**What does "trending" mean vs "most downloaded"?** `trending` uses Hugging Face's own trend signal (recent momentum), while `downloads`/`likes` are all-time popularity. Pick the sort that matches your question.

**Can I schedule it?** Yes — set `mode: "monitor"` and attach an Apify Schedule (daily/weekly) to get only newly trending entries each run.

**Can I filter by task or library?** Yes — `pipelineTag` (e.g. `text-generation`) and `library` (e.g. `diffusers`) for models, plus free-text `search` and Hub `tags` for both models and datasets.

**How are gated models handled?** They're included in the output with `gated` set (`"manual"`/`"auto"`) so you can see them trending; downloading their files requires an authorized token.

**Does it use a browser?** No — it calls the official Hugging Face Hub REST API over HTTP only, which keeps runs fast and cheap.

# Actor input Schema

## `dataType` (type: `string`):

What to pull. models = trending Hugging Face models. datasets = trending datasets. both = run both in one run (returned in one dataset, each row tagged with resultType).

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

snapshot = return the current trending results (no state). monitor = on the first run store the trending IDs, then on later runs output ONLY entries that are NEW to the trending list since the previous run (ideal for scheduled daily/weekly alerts).

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

Ranking used for the results. "Trending" uses Hugging Face's own trending signal (not just raw downloads).

## `direction` (type: `string`):

Descending puts the top (most trending / most downloaded) first — the usual choice.

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

Restrict models to a single Hugging Face task. Leave empty for all tasks. For a task not listed here, use the free-text Search field instead. (Applies to models only.)

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

Restrict models to a single library/framework. Leave empty for all. (Applies to models only.)

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

Free-text search over model/dataset names (e.g. "llama", "whisper", "fineweb"). Combines with the other filters.

## `tags` (type: `array`):

Restrict results to entries carrying these Hugging Face tags (e.g. "conversational", "multilingual", "license:apache-2.0"). Leave empty for all.

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

Maximum number of results per data type (models and datasets counted separately). Higher limits are paged automatically via the Hub API Link header.

## `includeConfig` (type: `boolean`):

Fetch each model's config.json (architecture details) and attach it as a "config" field. Adds one extra request per model, so it is slower — leave off unless you need architecture metadata. (Applies to models only.)

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

Optional. The public Hub API works without a token; supply a token (huggingface.co/settings/tokens) only to raise rate limits or read gated/private repos you have access to. Stored securely.

## `requestDelayMs` (type: `integer`):

Throttle between Hugging Face API requests to respect rate limits. Increase if you see HTTP 429 responses.

## Actor input object example

```json
{
  "dataType": "models",
  "mode": "snapshot",
  "sort": "trending",
  "direction": "-1",
  "tags": [],
  "limit": 100,
  "includeConfig": false,
  "requestDelayMs": 250
}
```

# 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("dsh-org/huggingface-model-dataset-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dsh-org/huggingface-model-dataset-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 dsh-org/huggingface-model-dataset-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dsh-org/huggingface-model-dataset-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hugging Face Model & Dataset Trend Tracker",
        "description": "Track trending Hugging Face models and datasets by downloads, likes, and velocity. Filter by task, library, or tag. Monitor mode alerts you to newly trending entries. Built for ML engineers, DevRel, and AI researchers.",
        "version": "0.0",
        "x-build-id": "hMPre4XYpZ6YOfN2H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dsh-org~huggingface-model-dataset-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dsh-org-huggingface-model-dataset-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dsh-org~huggingface-model-dataset-tracker/runs": {
            "post": {
                "operationId": "runs-sync-dsh-org-huggingface-model-dataset-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dsh-org~huggingface-model-dataset-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-dsh-org-huggingface-model-dataset-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "dataType": {
                        "title": "Data type",
                        "enum": [
                            "models",
                            "datasets",
                            "both"
                        ],
                        "type": "string",
                        "description": "What to pull. models = trending Hugging Face models. datasets = trending datasets. both = run both in one run (returned in one dataset, each row tagged with resultType).",
                        "default": "models"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "snapshot",
                            "monitor"
                        ],
                        "type": "string",
                        "description": "snapshot = return the current trending results (no state). monitor = on the first run store the trending IDs, then on later runs output ONLY entries that are NEW to the trending list since the previous run (ideal for scheduled daily/weekly alerts).",
                        "default": "snapshot"
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "trending",
                            "downloads",
                            "likes",
                            "lastModified",
                            "createdAt"
                        ],
                        "type": "string",
                        "description": "Ranking used for the results. \"Trending\" uses Hugging Face's own trending signal (not just raw downloads).",
                        "default": "trending"
                    },
                    "direction": {
                        "title": "Sort direction",
                        "enum": [
                            "-1",
                            "1"
                        ],
                        "type": "string",
                        "description": "Descending puts the top (most trending / most downloaded) first — the usual choice.",
                        "default": "-1"
                    },
                    "pipelineTag": {
                        "title": "Task filter (pipeline tag)",
                        "enum": [
                            "text-generation",
                            "text-classification",
                            "text2text-generation",
                            "question-answering",
                            "fill-mask",
                            "token-classification",
                            "translation",
                            "summarization",
                            "feature-extraction",
                            "sentence-similarity",
                            "zero-shot-classification",
                            "text-to-image",
                            "image-to-image",
                            "image-classification",
                            "image-to-text",
                            "image-text-to-text",
                            "object-detection",
                            "image-segmentation",
                            "text-to-speech",
                            "automatic-speech-recognition",
                            "audio-classification",
                            "text-to-video",
                            "video-classification",
                            "tabular-classification",
                            "reinforcement-learning"
                        ],
                        "type": "string",
                        "description": "Restrict models to a single Hugging Face task. Leave empty for all tasks. For a task not listed here, use the free-text Search field instead. (Applies to models only.)"
                    },
                    "library": {
                        "title": "Library filter",
                        "enum": [
                            "transformers",
                            "diffusers",
                            "gguf",
                            "safetensors",
                            "pytorch",
                            "tensorflow",
                            "jax",
                            "sentence-transformers",
                            "transformers.js",
                            "peft",
                            "onnx",
                            "timm",
                            "spacy",
                            "stable-baselines3",
                            "llama.cpp"
                        ],
                        "type": "string",
                        "description": "Restrict models to a single library/framework. Leave empty for all. (Applies to models only.)"
                    },
                    "search": {
                        "title": "Search query (optional)",
                        "type": "string",
                        "description": "Free-text search over model/dataset names (e.g. \"llama\", \"whisper\", \"fineweb\"). Combines with the other filters."
                    },
                    "tags": {
                        "title": "Tag filters (optional)",
                        "type": "array",
                        "description": "Restrict results to entries carrying these Hugging Face tags (e.g. \"conversational\", \"multilingual\", \"license:apache-2.0\"). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Limit per data type",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of results per data type (models and datasets counted separately). Higher limits are paged automatically via the Hub API Link header.",
                        "default": 100
                    },
                    "includeConfig": {
                        "title": "Include model config",
                        "type": "boolean",
                        "description": "Fetch each model's config.json (architecture details) and attach it as a \"config\" field. Adds one extra request per model, so it is slower — leave off unless you need architecture metadata. (Applies to models only.)",
                        "default": false
                    },
                    "hfToken": {
                        "title": "Hugging Face token (optional)",
                        "type": "string",
                        "description": "Optional. The public Hub API works without a token; supply a token (huggingface.co/settings/tokens) only to raise rate limits or read gated/private repos you have access to. Stored securely."
                    },
                    "requestDelayMs": {
                        "title": "Delay between API requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Throttle between Hugging Face API requests to respect rate limits. Increase if you see HTTP 429 responses.",
                        "default": 250
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```