# OpenAlex Public Research Monitor (`snappytools/openalex-works-monitor`) Actor

Track the newest (or most cited) academic publications from the free OpenAlex catalogue of 250M+ scholarly works. Results are saved to the default dataset, ready for export to CSV, Excel, JSON or your BI tool.

- **URL**: https://apify.com/snappytools/openalex-works-monitor.md
- **Developed by:** [Snappy](https://apify.com/snappytools) (community)
- **Categories:** Education
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## OpenAlex Public Research Monitor – scholarly works scraper and publication export

Give it a keyword, an OpenAlex filter, or nothing at all, and it returns the newest or most cited academic publications from the free OpenAlex catalogue of 250M+ scholarly works. You get one row per work, with the title, authors, DOI, venue, citation count, open access status and topic.

Use it as an OpenAlex API alternative when you want a clean table without writing code or handling paging. Schedule it daily with newest-first sorting and you have a research alert feed.

### Why this one

- **No API key needed.** It reads the public OpenAlex data, so there is nothing to sign up for.
- **Search and filter together.** Combine a keyword with any OpenAlex filter, such as `type:article,is_oa:true` or `from_publication_date:2024-01-01`.
- **Three sort orders.** Sort by newest, most cited, or relevance (relevance needs a keyword).
- **Old work types are fixed for you.** Legacy types such as `journal-article` are converted to the current OpenAlex types automatically.
- **Never a silent empty run.** If your query matches nothing or fails, you get the most recent works instead, flagged with `query_applied: false`.
- **Pay per result.** $10.00 per 1,000 results, and runs with no results cost nothing.

### Quick start

```json
{
  "filter": "type:article",
  "maxPages": 1,
  "perPage": 10,
  "search": "",
  "sort": "publication_date:desc"
}
```

This returns the 10 newest articles in OpenAlex, one row each.

### What you can use it for

| Who | What for |
|---|---|
| R\&D and innovation teams | Watch new research in their field with a daily scheduled run |
| Librarians and research offices | Export recent output on a topic or institution with authors, venues and citation counts |
| Analysts and consultants | Pull the most cited works on a subject to seed a literature review or client briefing |
| Journalists and fact-checkers | Find recent studies on a news topic with their DOIs |
| Open access sourcing | Use `is_oa:true` to collect papers with free full-text links |

### How to use it

1. Click **Try for free**.
2. In **Keyword search**, type a topic, for example `machine learning in radiology`. Leave it empty to skip keyword search.
3. In **OpenAlex filter**, add a comma-separated filter, for example `type:article,is_oa:true`. Use `|` for OR, for example `type:article|review`.
4. Pick a **Sort order**: `publication_date:desc`, `cited_by_count:desc` or `relevance_score:desc`.
5. Set **Works per page** (1 to 200) and **Maximum pages** (1 to 5).
6. Click **Start**.

To build an alert feed, schedule the run daily with newest-first sorting.

### Input example

```json
{
  "search": "large language models",
  "filter": "type:article,is_oa:true,from_publication_date:2024-01-01",
  "sort": "publication_date:desc",
  "perPage": 25,
  "maxPages": 2
}
```

### What data you get

Each row is one scholarly work. In a test run on 25 Oct 2026 with the Quick start input, it returned 10 works.

| Field | What it is | Example |
|---|---|---|
| `id` | OpenAlex work ID | https://openalex.org/W7130721223 |
| `openalex_url` | OpenAlex page for the work | https://openalex.org/W7130721223 |
| `title` | Title of the work | Ilmu Pengetahuan dan Teknologi |
| `type` | Work type | article |
| `doi` | DOI link | https://doi.org/10.5281/zenodo.18708259 |
| `landing_page_url` | Landing page (HTTPS or null) | https://doi.org/10.5281/zenodo.18708259 |
| `publication_date` | Date published | 2026-10-25 |
| `publication_year` | Year published | 2026 |
| `authors` | List of author names | Fitria Nugrah Madani, Zulkifli Makmur |
| `author_count` | Number of authors | 2 |
| `institutions` | Author institutions | State University of Gorontalo |
| `venue` | Journal or repository | Zenodo (CERN European Organization for Nuclear Research) |
| `publisher` | Publisher | European Organization for Nuclear Research |
| `language` | Language code | id |
| `cited_by_count` | Number of citations | 0 |
| `is_open_access` | Whether it is open access | true |
| `open_access_status` | Open access type | green |
| `open_access_url` | Free full-text link (HTTPS or null) | https://doi.org/10.5281/zenodo.18708259 |
| `primary_topic` | Main topic | Research, Science, and Academia |
| `field` | Research field | Decision Sciences |
| `abstract` | Abstract, cut to 1,000 characters; null if unavailable | null |
| `query_applied` | True if your filter and search were used | true |
| `query` | The exact filter, search and sort sent to OpenAlex | type:article,to_publication_date:2026-10-25 |

### Pricing

| Event | Price |
|---|---|
| Result (each work written to the dataset) | $0.01 |

There is no start fee. Runs with no results cost nothing.

| Run | Cost |
|---|---|
| 100 results | $1.00 |
| 1,000 results | $10.00 |
| 10,000 results | $100.00 |

### Good to know

- **Limits.** Up to 200 works per page and 5 pages per run, so at most 1,000 works.
- **Data source.** All data comes from the public OpenAlex API, released under CC0.
- **Fallback results.** If your query matches nothing, is rejected or times out, you get recent works with `query_applied: false`. Check this field.
- **Newest sorting.** Future-dated placeholder records are left out when sorting by newest.
- **Secure links.** Links are always HTTPS. Plain `http://` links are upgraded, and other schemes become `null`. A few older repositories may not resolve after the upgrade, so use `doi` or `openalex_url` as a stable link.
- **Partial runs.** If a later page fails, works already collected are kept.
- **Public data only.** Only public scholarly metadata is collected.
- **Not affiliated.** This tool isn't affiliated with or endorsed by OpenAlex.

### FAQ

**Do I need an API key?** No.

**Why do I get works that don't match my search?** Your query probably matched nothing or failed. Those rows have `query_applied: false`.

**Can I use relevance sorting without a keyword?** No. Relevance only applies when you give a keyword search.

**Which work types can I filter on?** Valid types include `article`, `preprint`, `review`, `book`, `book-chapter`, `dataset` and `dissertation`.

### Getting the data out

Download results as Excel, CSV or JSON from the Output tab. Send them to Google Sheets, Slack, Zapier, Make or webhooks from the **Integrations** tab. Every run is also available through the Apify API, and you can schedule runs from **Schedules**.

### Questions or problems

Open an issue on the **Issues** tab and include the run link. I reply within one business day.

### Related tools

- [arXiv Paper Monitor](https://apify.com/snappytools/arxiv-paper-monitor): track new preprints from arXiv
- [SEC EDGAR Filings and Insider Trades Monitor](https://apify.com/snappytools/sec-edgar-filings-monitor): follow company filings and insider trades

# Actor input Schema

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

Optional full-text search across titles, abstracts and fulltext (e.g. machine learning in radiology).

## `filter` (type: `string`):

Optional OpenAlex filter string, comma-separated, e.g. type:article,is_oa:true or from_publication_date:2024-01-01. Legacy types such as journal-article are converted automatically to current OpenAlex types.

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

How results are ordered. Relevance only applies when a keyword search is given.

## `perPage` (type: `integer`):

Number of works to fetch per request (1-200).

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

Maximum number of pages to fetch (1-5).

## Actor input object example

```json
{
  "search": "",
  "filter": "type:article",
  "sort": "publication_date:desc",
  "perPage": 10,
  "maxPages": 1
}
```

# Actor output Schema

## `results` (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 = {
    "search": "",
    "filter": "type:article",
    "sort": "publication_date:desc",
    "perPage": 10,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("snappytools/openalex-works-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 = {
    "search": "",
    "filter": "type:article",
    "sort": "publication_date:desc",
    "perPage": 10,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("snappytools/openalex-works-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 '{
  "search": "",
  "filter": "type:article",
  "sort": "publication_date:desc",
  "perPage": 10,
  "maxPages": 1
}' |
apify call snappytools/openalex-works-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,snappytools/openalex-works-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/10jc3a43AgkT9OUtt/builds/CARSTncN8UVNzThft/openapi.json