# OpenAlex Academic Papers & Authors Tracker (`gochujang/openalex-papers-tracker`) Actor

Search and collect academic papers, authors, institutions, and journals from OpenAlex — a free, open scholarly knowledge graph with 250M+ works. Filter by year, citation count, open access, and research field. Ideal for academic research, citation analysis, and trend tracking.

- **URL**: https://apify.com/gochujang/openalex-papers-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Education, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

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

### What does OpenAlex Papers Tracker do?

**OpenAlex Papers Tracker** searches and collects **academic research** records from [OpenAlex](https://openalex.org) — a free, fully open scholarly knowledge graph with 250M+ works, 90M+ authors, and data on institutions, journals, and research concepts. This **OpenAlex papers tracker** provides structured access to **scientific publications data** including titles, abstracts, citation counts, open-access status, author affiliations, and venue details. Search by keyword, publication year, citation threshold, or research field, and retrieve clean JSON records ready for analysis — no API key required.

Unlike Semantic Scholar or Google Scholar, OpenAlex exposes a comprehensive, machine-readable **academic research API** under an open license (CC0), making it the ideal data source for large-scale literature mining, citation network analysis, and research trend tracking.

***

### Why use OpenAlex Papers Tracker?

- **Literature review automation** — Search thousands of papers by keyword or concept and pull structured metadata (title, abstract, authors, citations) into a spreadsheet or database in minutes instead of days
- **Citation analysis and impact measurement** — Retrieve citation counts, h-index data, and reference graphs for authors or institutions to quantify research impact
- **Research trend tracking** — Monitor how publication volume and citation velocity for topics like "large language models", "CRISPR", or "zero-knowledge proofs" evolve year over year
- **Competitive intelligence for R\&D teams** — Track which institutions and authors are publishing most in your domain, and what venues they target
- **Academic fintech and investment research** — Surface cutting-edge **scientific publications data** in AI, biotech, or crypto to identify emerging technologies before they reach the mainstream

***

### How to use OpenAlex Papers Tracker

1. Open the actor on Apify and click **Try for free**
2. Choose a `mode`: `works` (papers), `authors`, `institutions`, `concepts`, or `venues`
3. Enter a `search` query (e.g. `"large language models"`, `"blockchain consensus"`, `"CRISPR gene editing"`)
4. Apply optional `filters`: `publication_year` (e.g. `"2023-2024"`), `cited_by_count` (e.g. `">50"`), `open_access` (`true`/`false`)
5. Set `sortBy` (e.g. `"cited_by_count:desc"` or `"publication_date:desc"`) and `limit` (up to 10,000)
6. Toggle `includeAbstract` and `includeAuthors` as needed
7. Click **Start** — results are paginated automatically at 200 records per page
8. Download as JSON / CSV or connect via Apify API

***

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `works` | `works`, `authors`, `institutions`, `concepts`, or `venues` |
| `search` | string | — | Full-text search query (e.g. `"large language models"`, `"CRISPR"`) |
| `filters` | object | — | Optional: `publication_year` (`"2023-2024"` or `"2024"`), `cited_by_count` (`">10"`), `open_access` (`true`/`false`) |
| `sortBy` | string | `cited_by_count:desc` | Sort field and direction (e.g. `"publication_date:desc"`) |
| `limit` | integer | `100` | Max records to fetch (1–10,000) |
| `includeAbstract` | boolean | `true` | Include paper abstract (`works` mode only) |
| `includeAuthors` | boolean | `true` | Include author details (`works` mode only) |

#### Filter examples

| Goal | Filter config |
|------|--------------|
| Papers from 2024 only | `{ "publication_year": "2024" }` |
| Highly-cited papers (50+ citations) | `{ "cited_by_count": ">50" }` |
| Open-access papers from 2022–2024 | `{ "publication_year": "2022-2024", "open_access": true }` |

***

### Output

#### Mode: `works` — scientific papers

```json
[
  {
    "id": "W2964093445",
    "title": "Attention Is All You Need",
    "publication_year": 2017,
    "publication_date": "2017-06-12",
    "doi": "10.48550/arXiv.1706.03762",
    "open_access": true,
    "cited_by_count": 142000,
    "abstract": "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks...",
    "authors": [
      {
        "author_name": "Ashish Vaswani",
        "institution": "Google Brain",
        "orcid": "https://orcid.org/0000-0001-5229-0601"
      }
    ],
    "venue": "Advances in Neural Information Processing Systems",
    "concepts": ["Transformer", "Attention mechanism", "Deep learning"],
    "url": "https://openalex.org/W2964093445"
  },
  {
    "id": "W3177828909",
    "title": "Language Models are Few-Shot Learners",
    "publication_year": 2020,
    "publication_date": "2020-05-28",
    "doi": "10.48550/arXiv.2005.14165",
    "open_access": true,
    "cited_by_count": 38000,
    "abstract": "We demonstrate that scaling language models greatly improves task-agnostic, few-shot performance...",
    "authors": [
      { "author_name": "Tom Brown", "institution": "OpenAI" }
    ],
    "venue": "Advances in Neural Information Processing Systems",
    "concepts": ["GPT-3", "Few-shot learning", "Language model"],
    "url": "https://openalex.org/W3177828909"
  }
]
```

***

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | OpenAlex unique work identifier |
| `title` | string | Paper title |
| `publication_year` | integer | Year of publication |
| `publication_date` | string | Full ISO date (YYYY-MM-DD) |
| `doi` | string | Digital Object Identifier |
| `open_access` | boolean | Whether the paper is freely available |
| `cited_by_count` | integer | Total citation count as of query time |
| `abstract` | string | Paper abstract (if `includeAbstract` = true) |
| `authors` | array | Author names, institutions, and ORCIDs |
| `venue` | string | Journal or conference name |
| `concepts` | array | OpenAlex-assigned research concepts / topics |
| `url` | string | Direct link to the OpenAlex record |

***

### Cost estimation

| Event | Price | Example |
|-------|-------|---------|
| Actor start | $0.001 | One-time per run |
| Per record returned | $0.001 | — |
| **100 papers** | **$0.101** | Quick topic overview |
| **1,000 papers** | **$1.001** | Systematic literature review |
| **10,000 papers** | **$10.001** | Field-wide trend analysis |

***

### FAQ

**Do I need an API key or OpenAlex account?**
No. OpenAlex is a fully open, free API — no registration or API key required. This actor uses the public OpenAlex REST API with a polite crawling rate (3 concurrent requests, 300ms delay) to stay within the recommended usage limits.

**What is the difference between `works`, `authors`, and `institutions` modes?**
In `works` mode the actor returns individual **papers** with abstracts and citation counts. In `authors` mode it returns researcher profiles with h-index, total citations, and affiliated institutions. In `institutions` mode it returns university and research organization profiles. Use `concepts` or `venues` mode to explore topic taxonomies or journal/conference metadata.

**How many papers can I retrieve?**
The `limit` field supports up to **10,000 records** per run. For larger-scale corpus collection (e.g. all papers in a field), run multiple queries with different year filters and merge the results. OpenAlex indexes over 250M works in total.

> **Disclaimer:** This actor accesses publicly available **academic research** data from the OpenAlex API, which is released under the CC0 1.0 Universal public domain dedication. The developer is not affiliated with OpenAlex or OurResearch. Citation counts and metadata accuracy depend on OpenAlex's underlying data sources.

***

**Keywords:** OpenAlex papers tracker, academic research API, scientific publications data, literature review automation, citation analysis, research trend tracker, open access papers, scholarly knowledge graph, OpenAlex API, paper metadata scraper

***

### Related actors

- [Semantic Scholar Papers](https://apify.com/gochujang/semantic-scholar-papers) — Semantic Scholar's 200M+ paper index for cross-source academic research coverage
- [PubMed Medical Papers Tracker](https://apify.com/gochujang/pubmed-papers-tracker) — Biomedical literature from PubMed to complement OpenAlex cross-discipline data
- [Patent Search Tracker](https://apify.com/gochujang/patent-search-tracker) — US patents building on academic research found via OpenAlex

### Feedback

If this actor powers your academic research workflows, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/openalex-papers-tracker#reviews)

# Actor input Schema

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

What to search: works (papers), authors, institutions, concepts, or venues

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

Full-text search query (e.g. 'large language models', 'CRISPR', 'climate change')

## `filters` (type: `object`):

Optional filters: publication\_year (e.g. '2023-2024' or '2024'), cited\_by\_count (e.g. '>10'), open\_access (true/false)

## `sortBy` (type: `string`):

Sort field and direction (e.g. 'cited\_by\_count:desc', 'publication\_date:desc')

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

Maximum number of records to fetch

## `includeAbstract` (type: `boolean`):

Include paper abstract (only for works mode)

## `includeAuthors` (type: `boolean`):

Include author details (only for works mode)

## `includeLandscape` (type: `boolean`):

Optional parameter: includeLandscape

## Actor input object example

```json
{
  "mode": "works",
  "filters": {},
  "sortBy": "cited_by_count:desc",
  "limit": 100,
  "includeAbstract": true,
  "includeAuthors": true
}
```

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/openalex-papers-tracker"
        }
    }
}
```

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/6kBVcnwNAAvtaXKBW/builds/r5h65e3i78aWqV1uF/openapi.json