---
title: "Daily Hugging Face papers summarised by OpenAI in Notion"
kind: "Kit"
category: "Research"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/a40712b0-9704-4f74-8a4a-22a6a0919b57"
updated: "2026-11-12"
---

# Daily Hugging Face papers summarised by OpenAI in Notion

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that reads Hugging Face’s list of daily papers each weekday morning and asks OpenAI to digest every abstract. It saves one Notion row for each new paper and skips papers that are already in the table.

Daily Hugging Face papers summarised by OpenAI in Notion is an n8n workflow in the Research category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow files a short digest of every new Hugging Face daily paper in a Notion table. Each weekday at 8:00 it asks the Hugging Face API for the papers of the day before. For each paper it looks in Notion for the paper’s address and skips it if it is there. A new paper’s abstract goes to OpenAI, which returns a core idea, keywords, results, technical details and a classification. Seven nodes do the work. Notion gets one row for each new paper.

### Who it suits

Researchers, machine learning engineers and reading groups who want a searchable archive of daily papers without opening every abstract. Skip it if you need the full text, because it keeps only the abstract and the digest. The digest comes from a language model and can be wrong.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Research | Research teams | Keep a searchable log of new papers | A lab reads the Notion table each morning and opens only the papers whose keywords match its project. |
| Education | Course leaders | Pick reading for a seminar | A lecturer filters the Classification column for reinforcement learning and chooses next week’s papers. |
| Technology | Engineering managers | Follow the field without reading everything | A manager scans the Core Introduction column on Friday and forwards three papers to the team. |
| Media | Newsletter writers | Find topics for a weekly AI digest | A writer sorts the table by date and picks the papers with the clearest results line. |

You need basic n8n skills, a Notion database with nine properties and an OpenAI API key.

### Where to use it

Any n8n that can reach Hugging Face, Notion and the OpenAI API will run it. Once you activate it, it runs by itself.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps
- Another schedule: change the days and the hour in the first node
- Another model: change \`modelId\` in \`OpenAI Analysis Abstract\`, and keep the JSON field names

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. The Notion table must carry the property names the workflow writes to.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Notion | A Notion integration and a database with the properties \`URL\` (URL), \`title\` (title), \`scrap-date\` (date) and \`abstract\`, \`Classification\`, \`Technical\_Details\`, \`Data\_and\_Results\`, \`keywords\` and \`Core Introduction\` (text) |
| OpenAI | An API key, saved in an OpenAI credential |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. In Notion, create a database with the nine properties listed above and share it with your Notion integration.
3. Add a Notion credential and select it in `Check Paper URL Existed` and in `Store Abstract Notion`.
4. In both Notion nodes, pick your database in place of `<YOUR_NOTION_DATABASE_ID>`.
5. Add an OpenAI credential and select it in `OpenAI Analysis Abstract`.
6. Run it once with Execute workflow and look at the Notion table.
7. Activate the workflow so that the schedule runs it.

### How to use it

Activate the workflow, or run it by hand to test it. After that it fetches the papers of the previous day on its own and adds the new ones to the table.

What to change for a different result

| To change | Where |
| --- | --- |
| The days and the hour | \`Schedule Trigger\` |
| The day of the papers | The \`date\` query value in \`Get Daily Papers\` |
| The number of papers | A \`limit\` query value in \`Get Daily Papers\`, from 1 to 100, with 50 as the default |
| What the model extracts | The system message in \`OpenAI Analysis Abstract\` and the matching properties in \`Store Abstract Notion\` |
| The model | \`modelId\` in \`OpenAI Analysis Abstract\` |
| The Notion table | The database in \`Check Paper URL Existed\` and in \`Store Abstract Notion\` |

### Example

On Wednesday at 8:00 the workflow asks Hugging Face for Tuesday’s papers.

It looks up each paper’s address in the Notion table and sends the abstracts of the new ones to OpenAI. The table gains a row for each, with the title, the abstract and the five fields of the digest.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. An API is a web address that answers programs with data instead of a web page. Here Hugging Face’s API returns the list of the day’s papers.

**For experts.** The request goes to `/api/daily_papers` with a `date` query, and the HTTP Request node turns the JSON array into one item per paper. `Loop Over Items` takes the papers one at a time. The Notion lookup has `alwaysOutputData` on, so a paper that is not found still gives an empty item, which the If node reads as new. The OpenAI node calls Chat Completions with JSON output, and the answer arrives in `message.content`.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Get Daily Papers\` | Asks Hugging Face for the papers of the previous day | One item per paper, with \`paper.id\`, \`paper.title\` and \`paper.summary\` |
| \`Check Paper URL Existed\` | Looks for the paper’s address in the Notion table | With no match it returns an empty item |
| \`If\` | Sends new papers on and passes over the rest | An empty item means the paper is new |
| \`OpenAI Analysis Abstract\` | Asks the model for five fields as JSON | The answer is read from \`message.content\` |
| \`Store Abstract Notion\` | Adds the row to the table | The abstract is cut at 2000 characters, the size of one Notion text block |

### Good to know

The page scraping was replaced by Hugging Face’s API, and the model was replaced. Mindket did not run this workflow.

- Source: the file read the HTML of the papers page by CSS class names, which break when the page design changes. Mindket’s copy asks \`/api/daily\_papers\`, which Hugging Face’s OpenAPI file, read on 12 November 2026, lists with a \`date\` parameter
- Model: the file used \`gpt-4o-2024-11-20\`, which OpenAI’s deprecations page, read on 12 November 2026, shuts down on 14 January 2027. Mindket’s copy uses \`gpt-6-luna\`, the replacement the page names. No tools are attached to it
- Dates: the run asks for yesterday’s date, so a Monday run asks for a Sunday. Hugging Face may list no papers for it, so move the days in \`Schedule Trigger\` if the table stays empty
- Quality: a language model writes the digest. Check a number against the paper before you quote it
- The file holds no credential and no Notion database ID

## README

```markdown
# Daily Hugging Face papers summarised by OpenAI in Notion

An n8n workflow that reads Hugging Face’s list of daily papers each weekday morning and asks OpenAI to digest every abstract. It saves one Notion row for each new paper and skips papers that are already in the table.

## What is inside

- `workflow.json`: the workflow as n8n exports it, seven nodes and no sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The original read the HTML of the Hugging Face papers page and of each paper’s page by CSS class names. Mindket’s copy asks the API route `/api/daily_papers` instead, which returns one item for each paper. The detail request, the two HTML extraction nodes and the Split Out node are gone, so seven nodes remain.
- The model was `gpt-4o-2024-11-20`, which OpenAI’s deprecations page, read on 12 November 2026, shuts down on 14 January 2027. Mindket’s copy uses `gpt-6-luna`.
- The Notion database ID and its cached name and address are gone. They are now `<YOUR_NOTION_DATABASE_ID>`, so you pick your own database.
- The system message ended with a stray code fence. It is cut.
- The Notion and OpenAI nodes were linked to credentials in the original owner’s n8n. The links are gone, so select your own.
- Nothing else. The schedule, the loop, the If node and the property names are the original copy’s own.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Notion integration and a database that has the properties named in the setup steps.
- An OpenAI API key.

## Set it up

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. In Notion, create a database with the nine properties listed above and share it with your Notion integration.
3. Add a Notion credential and select it in `Check Paper URL Existed` and in `Store Abstract Notion`.
4. In both Notion nodes, pick your database in place of `<YOUR_NOTION_DATABASE_ID>`.
5. Add an OpenAI credential and select it in `OpenAI Analysis Abstract`.
6. Run it once with Execute workflow and look at the Notion table.
7. Activate the workflow so that the schedule runs it.

## How a run goes

1. `Schedule Trigger` starts the run on weekdays at 8:00.
2. `Get Daily Papers` asks `/api/daily_papers` for the papers of the previous day and returns one item for each.
3. `Loop Over Items` takes the papers one at a time.
4. `Check Paper URL Existed` looks for the paper’s address in the Notion table.
5. `If` sends a paper that is not in the table to the model and lets the others go back to the loop.
6. `OpenAI Analysis Abstract` reads the abstract and returns the core introduction, keywords, data and results, technical details and classification as JSON.
7. `Store Abstract Notion` adds the row and returns to the loop for the next paper.

## Change the result

- The days and the hour: `Schedule Trigger`.
- The day of the papers: The `date` query value in `Get Daily Papers`.
- The number of papers: A `limit` query value in `Get Daily Papers`, from 1 to 100, with 50 as the default.
- What the model extracts: The system message in `OpenAI Analysis Abstract` and the matching properties in `Store Abstract Notion`.
- The model: `modelId` in `OpenAI Analysis Abstract`.
- The Notion table: The database in `Check Paper URL Existed` and in `Store Abstract Notion`.

## Good to know

- Mindket did not run this workflow. Hugging Face, Notion and OpenAI were not called. The route, its `date` and `limit` parameters and the fields of a paper come from Hugging Face’s OpenAPI file, and the node defaults from n8n’s source, read on 12 November 2026.
- The loop reads each paper’s fields with `$('Loop Over Items').item`, because the Notion lookup replaces the item with its own result.
- `gpt-6-luna` is used for a plain call. Do not give it tools in a Chat Completions node, because OpenAI’s model page says it calls tools there only with reasoning turned off.
- The original cut the abstract at 2000 characters, the size of one Notion text block, and Mindket’s copy does the same. Nothing else is cut.
- A Monday run asks for Sunday’s date, and Hugging Face may list no papers for it.
- The file holds no credential, no key and no Notion database ID.
```

## What is in it

3 files, 14 KB, downloaded as a zip.

```text
NOTICE.md  618 B
README.md  4 KB
workflow.json  9 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 7 steps, starting on a schedule
- AI: 1 step calls an AI model: OpenAI Analysis Abstract
- Sign-ins: Signs in to: Notion
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 6 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/a40712b0-9704-4f74-8a4a-22a6a0919b57)
- [Its page on Mindket](https://mindket.com/p/a40712b0-9704-4f74-8a4a-22a6a0919b57)
