# Hugging Face Papers Monitor (`realai_pl/hugging-face-papers-monitor`) Actor

Collect recent Hugging Face Daily Papers with source links, topic filters, and incremental delivery.

- **URL**: https://apify.com/realai\_pl/hugging-face-papers-monitor.md
- **Developed by:** [Dawid Mańkowski](https://apify.com/realai_pl) (community)
- **Categories:** AI, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 delivered hugging face papers

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 Papers Trend Monitor

Track fresh AI research from Hugging Face Daily Papers and detect which papers are gaining momentum instead of repeatedly exporting the same static feed.

### What this Actor gives you

Each delivered paper can include:

- paper ID, title, abstract, authors and claimed Hugging Face author profiles
- publication and Daily Papers submission timestamps
- Hugging Face upvotes and comment count
- current feed rank
- linked GitHub repository, GitHub stars and project page when Hugging Face provides them
- organization and submitter metadata when available
- Hugging Face AI summary and AI keywords when available
- direct Hugging Face and arXiv links
- persistent change history under your own `stateKey`

The source is the public Hugging Face Daily Papers API.

### The useful part: momentum tracking

On later runs with the same `stateKey`, the Actor compares the current paper snapshot with the previous one and adds:

- `previousUpvotes` / `upvotesDelta`
- `previousRank` / `rankDelta`
- `previousComments` / `commentsDelta`
- `previousGithubStars` / `githubStarsDelta`
- `changeType`: `NEW`, `CHANGED`, or `UNCHANGED`
- `firstSeenAt` and `lastSeenAt`

A positive `rankDelta` means the paper moved **up** in the feed (for example rank 20 → rank 5 gives `rankDelta: 15`). On the first observation, previous values and deltas are `null`.

This makes scheduled runs useful for research intelligence, newsletters, AI trend dashboards, RAG feeds, competitor/lab monitoring, and agent workflows.

### Input examples

#### Current trending papers

```json
{
  "sort": "trending",
  "limit": 50,
  "emitMode": "all"
}
```

#### Only new or changed papers about agents

```json
{
  "keyword": "agents",
  "sort": "trending",
  "minUpvotes": 5,
  "emitMode": "new_or_changed",
  "stateKey": "agents-watch"
}
```

#### Scan a week

```json
{
  "week": "2026-W39",
  "keyword": "vision language",
  "limit": 100,
  "maxPages": 5
}
```

You can use exactly one period selector at a time: `dates`, `week`, or `month`. If none is supplied, the latest feed is used. `submitter` can additionally restrict the Daily Papers feed to one Hugging Face submitter.

### Search and filters

`keyword` uses case-insensitive AND matching across the available title, abstract, AI summary, authors, Hugging Face author usernames, AI keywords, organization, GitHub URL, and project page. `minUpvotes` can remove low-signal papers before delivery.

`maxPages` controls how deeply the Actor scans the upstream feed when filters are selective. Hugging Face currently allows up to 100 records per source page.

### Delivery modes

- `all` — deliver every matching current paper
- `new` — deliver papers not previously seen under this `stateKey`
- `changed` — deliver only papers whose tracked momentum fields changed
- `new_or_changed` — deliver new papers plus changed existing papers

The older `onlyNew` input remains supported for backward compatibility. If it is enabled while `emitMode` is `all`, it behaves like `emitMode: new`.

The Actor stores up to 10,000 paper snapshots per monitoring key. Use a different `stateKey` for independent watchlists. Avoid concurrent runs with the same key because they share monitoring state.

### Output

Typical fields include:

`id`, `title`, `abstract`, `aiSummary`, `aiKeywords`, `authors`, `authorProfiles`, `publishedAt`, `submittedOnDailyAt`, `submittedBy`, `organization`, `upvotes`, `numComments`, `rank`, `githubRepo`, `githubStars`, `projectPage`, `changeType`, delta fields, `paperUrl`, `arxivUrl`, `firstSeenAt`, `lastSeenAt`, and `collectedAt`.

Hugging Face does not populate every enrichment field for every paper, so GitHub/project/AI metadata can be empty.

### Pricing

The PPE event `delivered-paper` costs **$0.003 per delivered row ($3 / 1,000 delivered papers)**. Rows suppressed by `emitMode` are not delivered and do not trigger the PPE event. Platform compute/storage can still be consumed by a run even when no rows are delivered.

`RUN_SUMMARY` reports fetched, delivered, new, changed and unchanged counts plus the active delivery mode.

### Reliability

The client uses bounded retries for transient HTTP 429 and 5xx responses and validates input limits before calling Hugging Face. Results still depend on the upstream public API and its current metadata.

This Actor is independent of and not endorsed by Hugging Face or arXiv.

# Actor input Schema

## `dates` (type: `array`):

ISO dates YYYY-MM-DD. Use this OR week OR month. Maximum 14 dates.

## `week` (type: `string`):

Example: 2026-W39. Use this OR dates OR month.

## `month` (type: `string`):

Example: 2026-09. Use this OR dates OR week.

## `submitter` (type: `string`):

Filter the Daily Papers feed by submitter username.

## `keyword` (type: `string`):

All words must match somewhere in title, abstract, AI summary, authors, AI keywords, organization, GitHub or project page.

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

Trending is recommended for momentum monitoring.

## `minUpvotes` (type: `integer`):

Ignore papers below this Hugging Face upvote count.

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

Maximum number of matching papers to inspect per run.

## `maxPages` (type: `integer`):

How deep to scan when local filters are selective. Each source page contains up to 100 papers.

## `emitMode` (type: `string`):

Change modes compare upvotes, rank, comments and GitHub stars against the previous run under the same monitoring key.

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

Backward-compatible shortcut. If enabled while What to deliver is All, it behaves like Only new papers.

## `stateKey` (type: `string`):

Use a distinct key for each independent scheduled watchlist.

## Actor input object example

```json
{
  "week": "",
  "month": "",
  "submitter": "",
  "keyword": "",
  "sort": "trending",
  "minUpvotes": 0,
  "limit": 50,
  "maxPages": 5,
  "emitMode": "all",
  "onlyNew": false,
  "stateKey": "default"
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("realai_pl/hugging-face-papers-monitor").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("realai_pl/hugging-face-papers-monitor").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 realai_pl/hugging-face-papers-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,realai_pl/hugging-face-papers-monitor"
        }
    }
}
```

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/NEMLqW6Ypq8Dv2wne/builds/sbRp589XNJge1ZLm5/openapi.json