# ROR Research Organization Registry Scraper (`automation-lab/ror-research-organization-registry-scraper`) Actor

🔎 Export normalized Research Organization Registry records with ROR IDs, locations, websites, domains, relationships, and external IDs.

- **URL**: https://apify.com/automation-lab/ror-research-organization-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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/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

## ROR Research Organization Registry Scraper

Find and export clean organization records from the public Research Organization Registry (ROR). This actor helps you turn ROR search results into a spreadsheet-ready dataset with ROR IDs, names, websites, countries, cities, domains, aliases, relationships, and external identifiers.

### What does ROR Research Organization Registry Scraper do?

ROR Research Organization Registry Scraper queries the official ROR organizations API and saves normalized organization rows to an Apify dataset.

It is useful when you need reliable organization identifiers for universities, hospitals, research institutes, companies, funders, nonprofits, archives, facilities, and government research organizations.

The actor uses HTTP requests to the public JSON API. It does not need a login, browser automation, or a private API key.

### Who is it for?

- 🧪 Research intelligence teams enriching institution lists.
- 🏫 University relations teams building clean affiliation directories.
- 🏥 Healthcare analysts mapping research hospitals and medical centers.
- 💼 B2B sales teams prospecting universities, hospitals, funders, and labs.
- 📚 Bibliometrics teams normalizing author affiliations.
- 🤝 Grant, funder, and vendor teams matching organizations across systems.
- 🧹 Data operations teams deduplicating names with persistent ROR IDs.

### Why use this actor?

ROR is a trusted open registry, but analysts often need data in repeatable CSV, JSON, Excel, or API workflows. This actor handles search, filters, pagination, normalization, and output formatting for you.

You can run it on a schedule, connect it to webhooks, or use it from the Apify API when you need fresh organization intelligence.

### Typical use cases

- Build a directory of active US education institutions.
- Export healthcare research organizations in a target country.
- Normalize company, hospital, or university names with ROR IDs.
- Collect domains for institutional email matching.
- Map organizations to Wikidata, GRID, ISNI, or FundRef identifiers.
- Feed CRM, enrichment, bibliometrics, and lead research pipelines.

### Data you can extract

| Field | Description |
|---|---|
| `rorId` | Compact ROR identifier. |
| `rorUrl` | Full ROR URL. |
| `name` | Primary organization name. |
| `status` | ROR status such as active. |
| `types` | Organization types such as education or healthcare. |
| `established` | Established year when available. |
| `countryCode` | ISO country code. |
| `countryName` | Country name. |
| `city` | City or location name. |
| `state` | Region or subdivision. |
| `domains` | Known web domains. |
| `websiteUrl` | Website link. |
| `aliases` | Alternative names. |
| `acronyms` | Acronyms. |
| `relationships` | Related organizations. |
| `wikidataIds` | Wikidata IDs. |
| `fundrefIds` | FundRef IDs. |

### How much does it cost to scrape ROR organizations?

This actor uses pay-per-event pricing. You pay a small run start fee and then a per-organization fee for each dataset row saved.

The default run is intentionally small and inexpensive. Increase `maxItems` when you are ready to export larger ROR result sets.

### Input options

Provide one or more search queries and optional filters.

```json
{
  "queries": ["university"],
  "countryCodes": ["US"],
  "organizationTypes": ["education"],
  "statuses": ["active"],
  "maxItems": 100,
  "requestDelayMs": 250,
  "includeRawData": false
}
```

### Search queries

Use organization names, keywords, or category-like terms.

Good examples:

- `university`
- `hospital`
- `cancer center`
- `max planck`
- `stanford`
- `research institute`

### Country filters

Use ISO 3166-1 alpha-2 country codes.

Examples:

- `US`
- `GB`
- `DE`
- `CA`
- `AU`
- `FR`

### Organization type filters

ROR commonly uses these types:

- `education`
- `healthcare`
- `company`
- `funder`
- `nonprofit`
- `government`
- `facility`
- `archive`
- `other`

### Status filters

Most production workflows should use:

- `active`

You can also omit the status filter if you want the API's broader default matching behavior.

### Output example

```json
{
  "rorId": "00f54p054",
  "rorUrl": "https://ror.org/00f54p054",
  "name": "Stanford University",
  "status": "active",
  "types": ["education", "funder"],
  "countryCode": "US",
  "countryName": "United States",
  "city": "Stanford",
  "domains": ["stanford.edu"],
  "websiteUrl": "https://www.stanford.edu",
  "wikidataIds": ["Q41506"],
  "query": "stanford"
}
```

### How to run the actor

1. Open the actor on Apify.
2. Enter one or more search queries.
3. Add country, type, or status filters if needed.
4. Set `maxItems` to the maximum number of organizations to export.
5. Start the run.
6. Download the dataset as CSV, JSON, Excel, XML, or RSS.

### Tips for better results

- Start broad with `university`, `hospital`, or `research institute`.
- Add `countryCodes` to keep output focused.
- Add `organizationTypes` when you need only universities, hospitals, companies, or funders.
- Use `includeRawData` when you need every original ROR source field.
- Run several smaller filtered searches instead of one huge unfocused query.

### Integrations

Use this actor with:

- CRM enrichment workflows for organization identity resolution.
- Grant prospecting pipelines that need funder and research institution metadata.
- Bibliometrics dashboards that normalize affiliation strings.
- University partnership databases.
- Data warehouse jobs that periodically refresh ROR IDs and domains.
- Vendor discovery systems that target public research organizations.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ror-research-organization-registry-scraper').call({
  queries: ['university'],
  countryCodes: ['US'],
  organizationTypes: ['education'],
  statuses: ['active'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ror-research-organization-registry-scraper').call(run_input={
    'queries': ['hospital'],
    'countryCodes': ['GB'],
    'organizationTypes': ['healthcare'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~ror-research-organization-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["university"],"countryCodes":["US"],"organizationTypes":["education"],"maxItems":100}'
```

### MCP usage

You can use this actor from Apify MCP in Claude Desktop, Claude Code, and other MCP-compatible tools.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper
```

Claude Code setup:

```bash
claude mcp add apify-ror "https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-ror": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper"
    }
  }
}
```

Example prompts:

- "Find active ROR education organizations in the United States and summarize the top domains."
- "Export healthcare research organizations in the United Kingdom from ROR."
- "Normalize this list of university names using ROR IDs."

### Scheduling

Schedule the actor weekly or monthly to refresh your organization reference table. ROR records can change as names, relationships, and external identifiers are updated.

### Webhooks

Attach an Apify webhook to send completed datasets into your own system, warehouse, or automation platform.

### Data quality notes

The actor returns data from the public ROR API. Some fields are optional because the source registry does not have every domain, coordinate, relationship, or external identifier for every organization.

### Legality

This actor uses a public registry API and exports factual organization metadata. Always use the data according to your local laws, ROR terms, and your organization's data governance policies.

### FAQ

#### Why did I get fewer rows than expected?

ROR search is relevance based and filters can narrow results. Try a broader query, remove a country or type filter, or increase `maxItems`.

#### Why are some fields empty?

Not every ROR organization has every optional field. Empty arrays or missing URLs usually mean the source record does not provide that data.

### Related scrapers

Other automation-lab actors can complement this workflow:

- https://apify.com/automation-lab/openalex-scraper
- https://apify.com/automation-lab/crossref-scraper
- https://apify.com/automation-lab/google-scholar-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

Initial version exports normalized ROR organization rows from the public API.

### Support

If you need a new field, a different filter, or a larger enrichment workflow, open an issue on the actor page.

### Field reference

`rorId` is the stable compact ID.

`rorUrl` is the canonical ROR URL.

`name` is the display name.

`types` contains all source organization types.

`domains` contains known domains.

`relationships` contains related organization summaries.

`gridIds`, `isniIds`, `fundrefIds`, and `wikidataIds` help match records across external systems.

### Performance

The ROR API returns up to 20 organizations per page. The actor paginates until it reaches `maxItems` or the result set ends.

### Reliability

The actor retries temporary API failures and uses a polite configurable delay between requests.

# Actor input Schema

## `queries` (type: `array`):

Organization names or discovery keywords to search in ROR, such as university, hospital, stanford, max planck, or cancer center.

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

Maximum number of ROR organization records to save across all queries.

## `countryCodes` (type: `array`):

Optional ISO 3166-1 alpha-2 country filters. Examples: US, GB, DE, CA, AU.

## `organizationTypes` (type: `array`):

Optional ROR type filters. Common values: education, healthcare, company, funder, nonprofit, government, facility, archive, other.

## `statuses` (type: `array`):

Optional status filters. Most workflows use active.

## `startPage` (type: `integer`):

ROR API page to start from. Leave as 1 for normal runs.

## `requestDelayMs` (type: `integer`):

Polite delay between ROR API pages. Increase if you run very large jobs.

## `includeRawData` (type: `boolean`):

Adds the full source organization JSON to each dataset item for auditing or custom post-processing.

## Actor input object example

```json
{
  "queries": [
    "university"
  ],
  "maxItems": 20,
  "countryCodes": [
    "US"
  ],
  "organizationTypes": [
    "education"
  ],
  "statuses": [
    "active"
  ],
  "startPage": 1,
  "requestDelayMs": 250,
  "includeRawData": false
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "university"
    ],
    "maxItems": 20,
    "countryCodes": [
        "US"
    ],
    "organizationTypes": [
        "education"
    ],
    "statuses": [
        "active"
    ],
    "startPage": 1,
    "requestDelayMs": 250,
    "includeRawData": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ror-research-organization-registry-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 = {
    "queries": ["university"],
    "maxItems": 20,
    "countryCodes": ["US"],
    "organizationTypes": ["education"],
    "statuses": ["active"],
    "startPage": 1,
    "requestDelayMs": 250,
    "includeRawData": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ror-research-organization-registry-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "university"
  ],
  "maxItems": 20,
  "countryCodes": [
    "US"
  ],
  "organizationTypes": [
    "education"
  ],
  "statuses": [
    "active"
  ],
  "startPage": 1,
  "requestDelayMs": 250,
  "includeRawData": false
}' |
apify call automation-lab/ror-research-organization-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/7xCDM7x3c9erq533b/builds/bV5RFgeKsQxg8Cn2T/openapi.json