# OpenAlex Scraper - Research Authors & Funders (`dataio/openalex-authors-affiliations`) Actor

Scrape OpenAlex academic publications as one row per author and affiliation, with ORCID, corresponding-author flag, institution, ROR ID, funders, grant IDs and field-normalized citation impact. Search by topic and year for research intelligence. No API key.

- **URL**: https://apify.com/dataio/openalex-authors-affiliations.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 author rows

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

### What does OpenAlex Scraper do?

Academic publications as **one row per author and affiliation** — with
ORCID, corresponding-author flag, institution, ROR and field-normalised
citation impact.

**No login. No API key. No proxies.**

### One row per researcher, not per paper

A paper with five authors across three institutions is **five researchers
and three labs**, not one row. For anyone selling into research, recruiting,
or mapping a field, the nested author array is the wrong shape.

An author affiliated with two institutions gets two rows — because that is
two labs to approach, not one.

### Three fields that do the work

**`isCorresponding`** — the corresponding author handles the paper's
correspondence. It is the only author you know is reachable. It is also a
sharply better list: measured on CRISPR papers, corresponding authors carry
**96 % ORCID coverage** against 69–80 % for all authors, at 3.5 rows per
paper instead of 10.9.

**`orcid`** — the researcher's permanent identifier. It survives name
changes and moves between institutions, which plain names do not.

**`fwci`** — field-weighted citation impact. 1.0 is the world average *for
that field and year*; 16.0 is sixteen times it. A raw citation count cannot
be compared between disciplines — a well-cited maths paper and a well-cited
oncology paper differ by an order of magnitude. This one can.

### Output

| Field | Example |
|---|---|
| `authorName`, `orcid` | Martin Jínek, 0000-0002-… |
| `authorPosition` | first / middle / last |
| `isCorresponding` | true |
| `institution`, `institutionRor` | University of Zurich, 02crff812 |
| `institutionCountry`, `institutionType` | CH, education |
| `rawAffiliation` | the department line as printed |
| `title`, `doi`, `workUrl` | |
| `journal`, `publisher`, `issn` | Nature Reviews Molecular Cell Biology |
| `publicationYear`, `publicationDate`, `type`, `language` | |
| `citedByCount`, **`fwci`**, `referencedWorksCount` | 117, 16.05 |
| `isOpenAccess`, `oaStatus`, `oaUrl` | |
| `isRetracted` | flagged rather than hidden |
| `topics`, `keywords`, `funders` | |

### Input

```json
{
  "searchText": "machine learning",
  "fromYear": 2025,
  "correspondingOnly": false,
  "maxItems": 500
}
```

| Field | Default | Notes |
|---|---|---|
| `searchText` | `machine learning` | Titles and abstracts |
| `fromYear` / `toYear` | 2025 | Publication year range |
| `correspondingOnly` | `false` | The contactable list |
| `maxItems` | `500` | Counts author rows, not papers |
| `contactEmail` | — | See below |
| `institutionCountry` | — | `US`, `FR`, `DE`, `CN` |
| `institutionRor` | — | One institution, e.g. `03vek6s52` |
| `workType` | `all` | Articles, reviews, preprints, datasets |
| `minCitations` | — | Filters uncited work |
| `openAccessOnly` | `false` | Fills the PDF link |

**About `contactEmail`.** OpenAlex reserves a much larger rate limit for
callers who identify themselves. Without it, large runs hit throttling and
slow down — the Actor backs off and continues, but it takes longer. The
address goes only to OpenAlex, and the field is optional by design.

### Limits, honestly

- **An institution filter matches papers, not authors.** Filtering by
  Harvard's ROR returns papers *with at least one* Harvard author — and
  every author on those papers is exported, including the other forty-nine.
  In testing, one 50-author physics collaboration filled an entire run.
  Filter rows on `institutionRor` after export when you want only that
  institution's people.
- **`fwci` needs time to mean anything.** A paper published last month has
  not been cited yet. Combining a recent year with `minCitations` will
  return almost nothing.
- Author rows multiply fast. Large collaborations carry hundreds of
  signatories; `maxItems` counts rows, so set it with that in mind.
- ORCID coverage varies by field and is best among corresponding authors.
- Some authors have no institution recorded; those rows keep the author and
  leave the institution empty rather than being dropped.
- Retracted papers are flagged, not removed. Check `isRetracted`.
- Author names, ORCIDs and affiliations are personal data published in the
  scholarly record. Using them for outreach in the EU or UK makes you the
  data controller.
- Not affiliated with OpenAlex or OurResearch.

### How much does it cost?

You pay per author row returned: **$0.003 each**, that is $3.00 per 1,000. There is no start fee, and subscription plans pay less per author row.

The example input below asks for up to 500 author rows, so it costs **$1.50 at most**.

If a run reaches the spending limit you set, the output stops at that limit and never goes past it. You are never charged for rows that were not delivered.

### Use OpenAlex Scraper as an API

Call it from your own code with the Apify client, here in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/openalex-authors-affiliations").call(run_input={
    'searchText': 'machine learning',
    'fromYear': 2025,
    'maxItems': 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works from JavaScript, Make, Zapier, n8n, and from AI agents through the Apify MCP server.

### Other actors you might like

- [Wikipedia Pageviews Scraper](https://apify.com/DataIO/wikipedia-pageviews-by-language): By Language
- [Bluesky Followers Scraper](https://apify.com/DataIO/bluesky-followers-exporter): Export Audiences
- [Google Trends Scraper & API](https://apify.com/DataIO/google-trends-scraper): 100 Keywords

### FAQ

#### Is it legal to use this data?

The actor reads public data from its official source, without logging in and without bypassing any access control. What you do with the data, for example contacting people listed in it, is your responsibility under the laws that apply to you, such as GDPR in Europe.

#### Can I run it on a schedule?

Yes. Create a schedule in Apify Console, daily or weekly for example, and each run delivers a fresh dataset, which you can send by email, webhook or integration.

#### Can AI agents use it?

Yes. It is available through the Apify MCP server, and every input field is described in its input schema, so an agent can call it directly.

# Actor input Schema

## `searchText` (type: `string`):

Searched across titles and abstracts — for example "CRISPR", "solid state battery", "large language model".

## `fromYear` (type: `integer`):

Earliest publication year.

## `correspondingOnly` (type: `boolean`):

The corresponding author is the one who handles correspondence for a paper — the only author you know is reachable. Turn this on for an outreach list, off to map a whole field.

## `maxItems` (type: `integer`):

One row per author and affiliation, so a five-author paper across three institutions yields more than five rows.

## `contactEmail` (type: `string`):

OpenAlex gives a much larger rate limit to callers who identify themselves. Supplying an address here makes large runs far faster. It is sent only to OpenAlex, and the Actor works without it — just more slowly.

## `institutionCountry` (type: `string`):

Two-letter code, for example US, FR, DE, CN.

## `institutionRor` (type: `string`):

ROR identifier of one institution, for example 03vek6s52 for Harvard. Find it at ror.org.

## `workType` (type: `string`):

Reviews attract more citations than articles; preprints are earliest.

## `minCitations` (type: `integer`):

Filters out uncited work. Recent papers have had little time to accumulate citations, so combine carefully with a recent year.

## `openAccessOnly` (type: `boolean`):

Keeps papers with a freely readable version, and fills the PDF link.

## `toYear` (type: `integer`):

Latest publication year.

## Actor input object example

```json
{
  "searchText": "machine learning",
  "fromYear": 2025,
  "correspondingOnly": false,
  "maxItems": 500,
  "workType": "all",
  "openAccessOnly": false
}
```

# Actor output Schema

## `results` (type: `string`):

Every row produced by the run, in JSON.

# 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 = {
    "searchText": "machine learning",
    "fromYear": 2025,
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/openalex-authors-affiliations").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 = {
    "searchText": "machine learning",
    "fromYear": 2025,
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/openalex-authors-affiliations").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 '{
  "searchText": "machine learning",
  "fromYear": 2025,
  "maxItems": 500
}' |
apify call dataio/openalex-authors-affiliations --silent --output-dataset

```

## MCP server setup

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

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/eeOVRBhP7Aij9UT9J/builds/UCKQZHEm3YbJtISFn/openapi.json