# ORCID Scraper · Researchers, Affiliations, Works & IDs (`reapx/orcid-scraper`) Actor

Scrape ORCID researcher profiles, affiliations, publications, IDs, and metadata from the open ORCID registry API. Features HTTP backoff and pay-per-event pricing.

- **URL**: https://apify.com/reapx/orcid-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (community)
- **Categories:** Developer tools, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 record returneds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## ORCID Scraper · Researchers, Affiliations, Works & IDs

The **ORCID Scraper** extracts structured researcher profiles, academic affiliations, publication histories, names, and persistent ORCID iDs from the open **ORCID** (Open Researcher and Contributor ID) public registry API. Designed for research analytics, academic recruitment, scientific bibliometrics, institutional reporting, and knowledge graph construction, this actor delivers high-speed, structured JSON dataset output without requiring API keys or browser automation.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is inferred, modelled or filled in, and a field absent from the source is absent from the row. The extracted archive for this source is browsable at [reapx.dev/data/orcid-scraper/](https://reapx.dev/data/orcid-scraper/) and mirrored as an open dataset on [Hugging Face](https://huggingface.co/datasets/reapxdev/orcid-scraper) and [Kaggle](https://www.kaggle.com/datasets/reapxdev/orcid-scraper). Questions: reapxdev@proton.me

***

### 💡 Key Features & Capabilities

- **Direct Open API Integration**: Built on top of the official `https://pub.orcid.org/v3.0/expanded-search/` REST API for fast, reliable data retrieval without browser overhead or CAPTCHA friction.
- **Flexible Solr / Lucene Querying**: Search by academic institution (e.g., `Stanford University`, `MIT`), researcher name cohort (given/family names), subject area, or complex Solr query expressions.
- **Structured Affiliation Datasets**: Extract full list of affiliated universities, research centers, medical schools, and corporate R\&D divisions per scholar profile.
- **Unique Addressable Identifiers**: Guarantees total, non-constant 16-character `id` fields (`0000-0002-1825-0097`) for entity resolution and automatic deep data page generation.
- **Pay-Per-Event Pricing**: Charged strictly per valid researcher record returned. Empty queries, rate-limit 429 backoffs, and network retries are 100% free.
- **Automatic HTTP Backoff & Resilience**: Native handling of HTTP 429 rate limits and 5xx server responses using exponential backoff retry logic.

***

### ⬇️ Input

The **ORCID Scraper** interface allows granular filtering by institution name, author given/family names, research topic keywords, or raw Solr search queries.

#### Input Schema Fields

| Field Name | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `query` | `string` | `"Stanford University"` | Main search term or query expression for ORCID researchers (e.g., institution name <code>Stanford University</code>, topic <code>Genomics</code>, or Solr syntax). |
| `institution` | `string` | `""` | Filter ORCID researchers by specific academic institution or organization name (e.g., <code>Harvard University</code>, <code>MIT</code>). |
| `givenNames` | `string` | `""` | Filter ORCID researcher profiles by given or first name (e.g., <code>Alexander</code>, <code>Elena</code>). |
| `familyNames` | `string` | `""` | Filter ORCID researcher profiles by family name or surname (e.g., <code>Smith</code>, <code>Zhang</code>). |
| `maxItems` | `integer` | `50` | Maximum number of researcher profiles to extract from the public registry (1 to 10,000). |

#### Example Input Configurations

##### Example 1: Extract Researchers by Institution

```json
{
  "query": "affiliation-org-name:\"Stanford University\"",
  "institution": "Stanford University",
  "maxItems": 100
}
```

##### Example 2: Search Researchers by Surname Cohort

```json
{
  "familyNames": "Smith",
  "maxItems": 50
}
```

##### Example 3: Search Scholars in Quantum Computing

```json
{
  "query": "quantum computing",
  "maxItems": 200
}
```

***

### ⬆️ Output

Every extracted researcher profile is written as a structured JSON object to the run's default dataset.

#### Dataset Field Specifications

| Column Name | Data Type | Description | Example |
| :--- | :--- | :--- | :--- |
| `id` | `string` | Canonical 16-character ORCID iD (Primary Key). | `"0000-0003-3972-0390"` |
| `orcidId` | `string` | Raw ORCID iD string matching `id`. | `"0000-0003-3972-0390"` |
| `orcidUrl` | `string` | Canonical URL to researcher's public ORCID profile. | `"https://orcid.org/0000-0003-3972-0390"` |
| `givenNames` | `string` | Given or first name(s) of the researcher. | `"George"` |
| `familyNames` | `string` | Family name or surname of the researcher. | `"Plafker"` |
| `creditName` | `string` | Published credit name as specified by researcher. | `"George Plafker"` |
| `name` | `string` | Primary display name for the scholar. | `"George Plafker"` |
| `otherNames` | `array[string]` | Alternative name variants used in publications. | `["G. Plafker"]` |
| `emails` | `array[string]` | Public email addresses declared on profile. | `["gplafker@example.org"]` |
| `institutions` | `array[string]` | List of affiliated universities & organizations. | `["Brooklyn College", "Stanford University"]` |
| `institutionCount` | `integer` | Count of total affiliated institutions. | `2` |
| `searchQuery` | `string` | Search query used to discover this profile. | `"Stanford University"` |

#### Sample JSON Output

```json
{
  "id": "0000-0003-3972-0390",
  "orcidId": "0000-0003-3972-0390",
  "orcidUrl": "https://orcid.org/0000-0003-3972-0390",
  "givenNames": "George",
  "familyNames": "Plafker",
  "creditName": "George Plafker",
  "name": "George Plafker",
  "otherNames": [
    "G. Plafker"
  ],
  "emails": [],
  "institutions": [
    "Brooklyn College",
    "Stanford University",
    "U.C. Berkeley"
  ],
  "institutionCount": 3,
  "searchQuery": "Stanford University"
}
```

***

### How it works

1. **Query Construction**: The actor constructs a validated Solr query string combining institution filters, researcher names, keywords, or custom search expressions.
2. **Direct API Dispatch**: Performs lightweight, high-performance HTTP requests directly against the public ORCID v3.0 REST API endpoint (`https://pub.orcid.org/v3.0/expanded-search/`).
3. **Resilient Backoff**: If ORCID API returns a 429 Rate Limit or temporary 5xx server error, the actor automatically enters an exponential backoff loop (1s, 1.5s, 2.25s...) until the endpoint responds cleanly.
4. **Streaming Push & Pay-Per-Event Charging**: As records are returned in pages of 100, items are transformed, validated, and pushed directly to the default dataset while triggering `record-returned` PPE event charging.
5. **Durable Dataset Naming**: Names the default dataset at startup (`orcid-scraper-{run_id}`) to ensure long-term indexing and archival compatibility across [reapx.dev](https://reapx.dev/data/orcid-scraper/).

***

### ❓ FAQ

#### What is ORCID?

ORCID (Open Researcher and Contributor ID) is a non-profit organization providing persistent digital identifiers that distinguish individual academic researchers and scholars across scientific publications, grants, and institutions.

#### Is an API key required to run this actor?

No. The ORCID expanded-search endpoint is publicly accessible and does not require authentication or private API keys.

#### How is pricing calculated?

This actor uses **Pay-Per-Event (PPE)** pricing charged at **$0.002 per researcher record returned**. You are only charged for actual data records pushed to your dataset. Failed runs, empty search queries, or rate-limited retries incur zero charges.

#### Can I run large-scale institutional bulk extractions?

Yes. Set `maxItems` up to 10,000 to extract comprehensive scholar directories for major universities or research fields.

***

### 💬 Your feedback

We continuously improve our scrapers based on user feedback. If you encounter any bugs, request additional fields (such as work titles or grant IDs), or need custom dataset exports, please contact us at **reapxdev@proton.me** or visit [reapx.dev](https://reapx.dev).

***

*Disclaimer: Unofficial - not affiliated with ORCID. Collects public data only. reapx. Contact reapxdev@proton.me.*

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "query": "affiliation-org-name:\"Stanford University\"",
  "institution": "Stanford University",
  "maxItems": 50
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "id": "0000-0003-3972-0390",
  "orcidId": "0000-0003-3972-0390",
  "orcidUrl": "https://orcid.org/0000-0003-3972-0390",
  "givenNames": "George",
  "familyNames": "Plafker",
  "creditName": "",
  "name": "George Plafker",
  "otherNames": [],
  "emails": [],
  "institutions": [
    "Brooklyn College",
    "Stanford University",
    "U.C. Berkeley"
  ],
  "institutionCount": 3,
  "searchQuery": "Stanford University"
}
```

### ⚠️ Run outcomes and error handling

This Actor reports what happened in the run's **status message**, and it always keeps whatever it collected. These are the outcomes you can get and what each one means.

| Outcome | What it means |
|---|---|
| **Success** | Rows were returned and you were charged `record-returned` at $0.002 per row. |
| **No matches** | The source returned nothing for your filters. **Nothing is charged.** Widen the date window or drop a filter. |

#### What is guaranteed either way

- **Every row is pushed as it is built**, not buffered to the end of the run. Anything that buffers output loses everything to a timeout, a block or a migration; this does not.
- **A field absent from the source is absent from the row.** Nothing is inferred, modelled or filled in to make a row look complete.

# Actor input Schema

## `query` (type: `string`):

Search term or query expression for ORCID researchers (e.g., institution name <code>Stanford University</code>, research area <code>Genomics</code>, author name, or Solr query). Leave empty to run default query.

## `institution` (type: `string`):

Filter ORCID researchers by academic institution or affiliated organization name (e.g., <code>Harvard University</code>, <code>MIT</code>). Leave empty to search across all institutions without restriction.

## `givenNames` (type: `string`):

Filter ORCID researcher profiles by given or first name (e.g., <code>Alexander</code>, <code>Elena</code>). Leave empty to search across all given names without restricting by first name.

## `familyNames` (type: `string`):

Filter ORCID researcher profiles by family name or surname (e.g., <code>Smith</code>, <code>Zhang</code>). Leave empty to search across all family names without restricting by surname.

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

Maximum number of ORCID researcher profiles to extract from the public registry (1 to 10,000). The higher the number, the longer the run takes and the more pay-per-event records are charged. Default is 50.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## Actor input object example

```json
{
  "query": "Stanford University",
  "maxItems": 50
}
```

# Actor output Schema

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

Every ORCID researcher profile record extracted by this run, one row per researcher, in the default dataset.

# 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 = {
    "query": "Stanford University",
    "institution": "",
    "givenNames": "",
    "familyNames": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/orcid-scraper").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 = {
    "query": "Stanford University",
    "institution": "",
    "givenNames": "",
    "familyNames": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/orcid-scraper").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 '{
  "query": "Stanford University",
  "institution": "",
  "givenNames": "",
  "familyNames": "",
  "maxItems": 50
}' |
apify call reapx/orcid-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reapx/orcid-scraper"
        }
    }
}

```

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/APZkKySrGWyepMp1s/builds/AN36DkLTqsnRfh4sb/openapi.json