# ORCID Researcher Lookup — Public Profile API (`accountable_eel/orcid-researcher-lookup`) Actor

Look up researchers by ORCID iD against the official, free ORCID public registry. Get name, biography, country, employment history, keywords, and total works count. Pay only for iDs that resolve to a real record.

- **URL**: https://apify.com/accountable\_eel/orcid-researcher-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Developer tools, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

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

## ORCID Researcher Lookup

Look up any researcher by ORCID iD against the official, free [ORCID](https://orcid.org) public
registry — name, biography, country, full employment history, keywords, and total works count.
No API key, no scraping — this hits the official public ORCID API directly.

### Features

- **ORCID iD → full researcher profile.** Given name, family name, credit name, and a resolved
  display name.
- **Employment history.** Every employment record on file — organization, role, and start/end
  years — plus the inferred current employer (the most recent entry with no end year).
- **Biography, country & keywords.** The researcher's self-reported biography, country, and
  research keyword tags.
- **Works count.** A quick count of works linked to the profile.
- **Pay only for hits.** ORCID iDs that don't resolve to a real record cost nothing — see
  [Pricing](#pricing).
- **Built for bulk.** Feed in thousands of ORCID iDs; concurrency, keyword filtering, column
  selection, and a one-row-per-employment-record expansion are all configurable.

### How to use ORCID Researcher Lookup — Public Profile API

1. **In the Apify Console.** Open the actor page and click **Start** — the `orcidIds` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~orcid-researcher-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"orcidIds":["0000-0002-1825-0097"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "orcidIds": [
    "0000-0002-1825-0097"
  ]
}
```

One ORCID iD per line, in 0000-0002-1825-0097 format (a full orcid.org URL also works). Accepted formats: 0000-0002-1825-0097, https://orcid.org/0000-0002-1825-0097.

```json
{
  "orcidIds": ["0000-0002-1825-0097", "https://orcid.org/0000-0002-1825-0097"],
  "testRun": false,
  "onlyFound": false,
  "expandRows": false,
  "maxConcurrency": 5
}
```

`orcidIds` is a list of ORCID iDs — plain `0000-0002-1825-0097` format or a full `orcid.org` URL,
both work. `testRun` limits a run to the first 5 items so you can check your input before
spending on the full list. `onlyFound` hides rows where nothing was found (misses are always
free regardless). Optional `includeKeywords`/`excludeKeywords` filter results by keyword, and
`maxResults` stops the run early once that many results have been found. `columns` lets you pick
which fields to include (all are on by default). `expandRows` gives each employment record its
own row instead of grouping them under the ORCID iD — you're still only charged once per iD no
matter how many rows it produces. `maxConcurrency` (default 5, max 20) caps parallel requests.

### Output

| query | found | status | displayName | orcid | givenName | familyName | biography | country | keywords | currentEmployer | employments | worksCount | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0000-0002-1825-0097 | true | OK | Josiah Carberry | 0000-0002-1825-0097 | Josiah | Carberry | Josiah Carberry is a fictitious person. This account is used as a demonstration account by ORCID, CrossRef and others who wish to demonstrate the interaction of ORCID with other scholarly communication systems without having to use a real-person's account.

Josiah Stinkney Carberry is a fictional professor, created as a joke in 1929. He is said to still teach at Brown University, and to be known for his work in "psychoceramics", the supposed study of "cracked pots". See his Wikipedia entry for more details. |  | \["psychoceramics","ionian philology"] | Wesleyan University | \[{"organization":"Wesleyan University","role":"Professor","startYear":"1930","endYear":null},{"organization":"Brown University","role":"Professor","startYear":"1929","endYear":null}] | 6 | 2026-08-31T06:20:16.366Z |

One row per ORCID iD, for example:

```json
{
  "query": "0000-0002-1825-0097",
  "found": true,
  "status": "OK",
  "orcid": "0000-0002-1825-0097",
  "givenName": "Josiah",
  "familyName": "Carberry",
  "creditName": null,
  "displayName": "Josiah Carberry",
  "biography": "Josiah Carberry is a fictitious person...",
  "country": "US",
  "keywords": ["psychoceramics"],
  "employments": [
    { "organization": "Brown University", "role": "Professor", "startYear": "1975", "endYear": null }
  ],
  "currentEmployer": "Brown University",
  "worksCount": 27,
  "scrapedAt": "2026-08-21T12:00:00.000Z"
}
```

An ORCID iD with no matching record comes back as `"found": false` with `status: "NOT_FOUND"`
(or `"BAD_FORMAT"` if it doesn't match the `0000-0002-1825-0097` shape to begin with) and a
plain-English `message` — these rows are never charged.

### Use cases

- **Researcher identity verification.** Confirm a name, affiliation, and country before crediting
  or contacting an author.
- **Grant & publication pipelines.** Bulk-enrich a list of ORCID iDs with current employer and
  works count for reporting.
- **Institutional research audits.** Cross-check employment history against claimed
  affiliations.
- **Peer-review & editorial workflows.** Pull a reviewer or author's biography and keywords to
  assess subject-matter fit.
- **Academic directory building.** Turn a bare list of ORCID iDs into a searchable researcher
  directory.

### Pricing

$4 per 1,000 ORCID iDs, plus a $0.00005 start fee. Misses (`found:false`) are never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~orcid-researcher-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"orcidIds":["0000-0002-1825-0097"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~orcid-researcher-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"orcidIds":["0000-0002-1825-0097"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~orcid-researcher-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"orcidIds":["{{ORCID iD}}"]}`, mapping the row's ORCID iD into the `orcidIds` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "ORCID API — Researcher Identity & Employment Lookup" — the agent will find and run this actor.

### FAQ

**What counts as "not found"?** An ORCID iD that doesn't match the `0000-0002-1825-0097` format
is flagged `BAD_FORMAT` before a request is even made. A correctly formatted iD with no
registered ORCID record returns HTTP 404 and is flagged `NOT_FOUND`. Neither is charged.

**Can I paste a full orcid.org URL instead of the bare iD?** Yes — the actor extracts the
`0000-0002-1825-0097`-shaped iD from anywhere in the input string, so a full profile URL works
the same as the bare iD.

**How is "current employer" determined?** It's the most recent employment record with no
`endYear` on file; if every record has an end year, the actor falls back to the first
(most-recently-added) employment entry.

**Why does the actor set a custom Accept header?** ORCID's public API returns XML by default —
this actor explicitly requests `Accept: application/json` to get structured JSON instead.

**Is every field always populated?** No — biography, country, keywords, and employment history
depend entirely on what the researcher has chosen to make public on their ORCID profile; a
minimal profile may return mostly `null` fields alongside the name.

**What proxy should I use?** Apify Proxy is enabled by default; ORCID's public API is generally
permissive, but residential proxies are available if you see blocks on large runs.

# Actor input Schema

## `orcidIds` (type: `array`):

One ORCID iD per line, in 0000-0002-1825-0097 format (a full orcid.org URL also works). Accepted formats: 0000-0002-1825-0097, https://orcid.org/0000-0002-1825-0097. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each employment record found gets its own row instead of being grouped under its ORCID iD. You're still only charged once per ORCID iD, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "orcidIds": [
    "0000-0002-1825-0097"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "displayName",
    "orcid",
    "givenName",
    "familyName",
    "biography",
    "country",
    "keywords",
    "currentEmployer",
    "employments",
    "worksCount"
  ],
  "expandRows": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "orcidIds": [
        "0000-0002-1825-0097"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/orcid-researcher-lookup").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 = {
    "orcidIds": ["0000-0002-1825-0097"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/orcid-researcher-lookup").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 '{
  "orcidIds": [
    "0000-0002-1825-0097"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/orcid-researcher-lookup --silent --output-dataset

```

## MCP server setup

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

```

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/xqgJhu6orFTgefXfq/builds/sVzR4NrUxH4rOBrb8/openapi.json