# Research Organization Data — ROR Registry (Global Institutions) (`foxlabs/ror-research-organization-data`) Actor

Look up research organizations worldwide in the ROR registry by name, ROR ID, domain or country. Returns ROR ID, official and alternative names, organization type, country, city, website, Wikipedia page and cross-references to GRID, ISNI, Crossref Funder ID and Wikidata.

- **URL**: https://apify.com/foxlabs/ror-research-organization-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 company records

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

## Research Organization Data — ROR Registry (Global Institutions) 🌍

**foXLabs research-funding series:** [NSF awards](https://apify.com/foxlabs/nsf-awards-company-data) · [NIH grants](https://apify.com/foxlabs/nih-reporter-organization-data) · [Clinical trial sponsors](https://apify.com/foxlabs/clinical-trial-sponsor-data) · [US nonprofits](https://apify.com/foxlabs/us-nonprofit-data) · [Wikipedia company data](https://apify.com/foxlabs/wikipedia-company-scraper)

🎉 Resolve **any research organization in the world** — universities, institutes, hospitals, companies and funders — to a stable ROR ID with location, website, founding year and parent/child structure. No key, no login.
Built for anyone who has to match messy institution names to one canonical record.

### 🔍 What is this Actor — and when should you use it?

The Research Organization Registry (ROR) is the community-run, open registry of research organizations. This Actor searches it four ways — by **name**, by **ROR ID**, by **website domain**, or filtered by **organization type** — and returns one clean row per organization: canonical name, ROR ID, country and city, coordinates, website, Wikipedia page, founding year, and the organization's place in a parent/child hierarchy.

**Use it when you need:** to deduplicate institution names across datasets; a canonical ID to join grant, publication or trial records on; the parent university behind a research institute; or a clean list of organizations of one type in one country.

**Use something else when:** you need funding amounts rather than organization identity — use [NSF](https://apify.com/foxlabs/nsf-awards-company-data) or [NIH](https://apify.com/foxlabs/nih-reporter-organization-data). For company registry filings, use the country registry Actors in the foXLabs suite.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/ror-research-organization-data`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered organization row.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
Run the Apify actor foxlabs/ror-research-organization-data with
{"queries":["Max Planck Society","novartis.com"],"maxResultsPerQuery":10}
and give me the ROR IDs, countries and websites.
```

### 📋 Overview

| | |
|---|---|
| **Source** | Research Organization Registry (ROR) |
| **Coverage** | Global — research organizations of every type, in every country |
| **Auth needed** | None. No API key, no login, no proxy required |
| **Row** | One research organization |
| **Measured run** | 31 rows in 5.0 s for 4 queries (2026-09-20, build 0.1.8) |
| **Pricing** | $0.003 per delivered row — $3 per 1,000 |

### ✨ Features

- 🔑 **Four ways in** — organization name, ROR ID, website domain, or a type filter
- 🆔 **Stable ROR ID** on every row — the join key for research data
- 📍 **Coordinates** (latitude/longitude) and city on every row
- 🔗 **Website and Wikipedia page** on every row
- 🏛️ **Hierarchy** — parent, child and related organizations
- 🏷️ **Multilingual labels** — the organization's name in other languages
- 🎯 **Type filter** — company, education, healthcare, government, facility, nonprofit, funder, archive, other
- ⚡ **Key-free and fast** — 31 rows in 5 seconds, no proxy

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~ror-research-organization-data/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Siemens","Max Planck Society","059mq0909","novartis.com"],"maxResultsPerQuery":10}'
```

### 🚀 Getting Started (3 steps)

1. **Put anything you have into `queries`** — a name, a ROR ID, or a domain. The default run shows all three forms at once.
2. **Narrow by type if you want.** `organizationType` restricts results to e.g. `education` or `healthcare`.
3. **Run it.** Rows arrive in the dataset; export to CSV/JSON/Excel or read them over the API.

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["Siemens","Max Planck Society","059mq0909","novartis.com"]` | Organization names, ROR IDs or website domains |
| `organizationType` | string | `""` (all) | `company`, `education`, `healthcare`, `government`, `facility`, `nonprofit`, `funder`, `archive`, `other` |
| `maxResultsPerQuery` | integer | `10` | Cap on organizations returned per query |
| `maxConcurrency` | integer | `5` | Parallel requests against ROR |
| `requestDelayMs` | integer | `0` | Optional pause between requests |
| `includeRaw` | boolean | `false` | Attach the untouched ROR record to each row |
| `proxyConfiguration` | object | proxy off | ROR answers direct requests; enable only if you need it |

**Example — resolve a list of messy names:**

```json
{ "queries": ["MIT", "ETH Zurich", "Karolinska"], "maxResultsPerQuery": 3 }
```

**Example — hospitals only:**

```json
{ "queries": ["cancer center"], "organizationType": "healthcare", "maxResultsPerQuery": 50 }
```

### 📤 Output

One row per organization. Fill rates below are from the measured run (31 rows, 4 queries, 2026-09-20):

| Field | Type | Fill | Description |
|---|---|---|---|
| `companyName` | string | 100% | Canonical organization name |
| `registrationNumber` | string | 100% | Full ROR ID URL — the stable identifier |
| `status` / `statusRaw` | string | 100% | Active/inactive state in ROR |
| `legalForm` | string | 100% | ROR organization types, comma-joined (e.g. `company, funder`) |
| `incorporatedOn` | string | 100% | Founding date derived from the established year |
| `establishedYear` | number | 100% | Year the organization was established |
| `city` | string | 100% | City |
| `countryName` / `countryCode` | string | 100% | Country and ISO code |
| `latitude` / `longitude` | number | 100% | Coordinates |
| `website` | string | 100% | Organization website |
| `wikipediaUrl` | string | 100% | Wikipedia page |
| `labels` | array | 100% | Names in other languages |
| `externalIds` | object | 100% | Cross-registry ids (GRID, ISNI, Wikidata, Fundref …) |
| `parentOrganizations` | array | 87% | Parent organizations in ROR's hierarchy |
| `childOrganizations` | array | 29% | Child organizations, where the record has them |
| `aliases` | array | 26% | Alternative names, where published |
| `relatedOrganizations` | array | 16% | Related organizations, where published |
| `domains` | array | 13% | Web domains — ROR fills this for a minority of records |
| `sourceUrl` | string | 100% | ROR page for the organization |
| `country` / `registry` / `query` / `scrapedAt` | string | 100% | Provenance fields |

The hierarchy, alias and domain fields are sparse by nature — ROR records vary in depth — and the percentages above say exactly how sparse. Columns ROR does not publish at all (tax number, street address, industry code, headcount, capital, contact details) were removed rather than shipped permanently empty.

**A real row from the default run:**

```json
{
  "companyName": "Siemens (Germany)",
  "registrationNumber": "https://ror.org/059mq0909",
  "status": "active",
  "legalForm": "company, funder",
  "establishedYear": 1847,
  "city": "Munich",
  "countryName": "Germany",
  "countryCode": "DE",
  "latitude": 48.13743,
  "longitude": 11.57549,
  "website": "http://www.siemens.com/entry/cc/en/",
  "wikipediaUrl": "https://en.wikipedia.org/wiki/Siemens"
}
```

### 💼 Use cases

- **Entity resolution** — turn a column of messy institution names into canonical ROR IDs
- **Data joining** — ROR IDs are the standard key across grant, publication and trial datasets
- **Hierarchy mapping** — find the parent university behind an institute, or all children of a system
- **Geographic analysis** — coordinates on every row, so organizations plot straight onto a map
- **Cross-registry linking** — `externalIds` carries GRID, ISNI, Wikidata and Fundref identifiers

### 🔗 Integration

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/ror-research-organization-data').call({
  queries: ['Max Planck Society'], maxResultsPerQuery: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/ror-research-organization-data").call(
    run_input={"queries": ["Max Planck Society"], "maxResultsPerQuery": 10}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**No-code:** Make, n8n and Zapier reach this Actor through the Apify app — schedule it and push resolved organizations into a sheet or a database.

### 📊 Pricing

Pay-per-event: **`company-record` — $0.003 per delivered row ($3 per 1,000)**. Compute and traffic are included; you pay for rows, not run time. Rows without an organization name are not charged.

[View current pricing.](https://apify.com/foxlabs/ror-research-organization-data)

### ❓ FAQ

**Do I need a ROR API key?** No. ROR is open infrastructure and this Actor needs no key, login or proxy.

**Can I look up by domain?** Yes — put the domain in `queries` (e.g. `novartis.com`). Names and ROR IDs work in the same field.

**Why is `domains` empty on most rows?** ROR populates that field for a minority of records; it came back on 13% of rows in the measured run. `website` is filled on every row and is the reliable one.

**Is the ROR data free to reuse?** ROR IDs and metadata are released under CC0. This Actor charges for running the extraction and delivering clean rows, not for the data itself.

**Does it include companies?** Yes — ROR covers companies and funders alongside universities and hospitals. The default run resolves Siemens and Novartis.

**How do I get everything of one type in a country?** Search a broad term with `organizationType` set, then filter the output by `countryCode`.

### 🐛 Troubleshooting

**A name returns several organizations.** Large institutions have national branches in ROR (`Siemens (Germany)`). Pick by `countryCode`, or search the ROR ID directly.

**A ROR ID returns nothing.** Pass the bare id (`059mq0909`) or the full URL — both work, but check for typos; ROR IDs are checksummed.

**Fewer rows than `maxResultsPerQuery`.** The cap is per query; a precise query (an ID or a domain) resolves to one organization by design.

### ⚠️ Trademark

ROR is a community-led registry operated by its member organizations. This Actor is an independent tool and is not affiliated with or endorsed by ROR. Organization names and logos belong to their respective owners.

### ⚖️ Is it legal to scrape this data?

ROR publishes its IDs and metadata under a CC0 public-domain dedication, explicitly for reuse, and states there are no restrictions on access to or use of ROR IDs and metadata. The rows this Actor returns are institutional records — not personal data. You remain responsible for how you use the output.

### 🤝 Support & contact

Questions, a field you need, or a bug: **info@foxlabs.com.tr** — or open an issue on the Actor's Apify page.

### Changelog

#### 0.1.8

- **Removed permanently-empty columns** (tax number, dissolution date, street address, postal code, industry, industry code, headcount, capital, e-mail, phone, officers) — ROR does not publish them. Row went from 37 columns to 26, with **zero permanently-empty columns** left.

#### 0.1

- ROR search by organization name, ROR ID or website domain, with an organization-type filter.
- Pay-per-event billing on delivered rows (`company-record`).

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/ror-research-organization-data/changelog.md

# Actor input Schema

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

Organization names (`Siemens`, `Max Planck`), ROR IDs (`059mq0909`) or website domains (`siemens.com`).

## `maxResultsPerQuery` (type: `integer`):

How many rows a single query may produce.

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

How many queries to run at the same time. Lower it if the source throttles you.

## `includeRaw` (type: `boolean`):

Attach the source's untouched response under `raw`. Useful when you need a field this actor does not map.

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

Politeness delay against a public source. Raise it for large runs.

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

Optional. The ROR API is open and rarely needs a proxy.

## `organizationType` (type: `string`):

Limit to one ROR type. `company` isolates corporate R\&D organizations.

## Actor input object example

```json
{
  "queries": [
    "Siemens",
    "Max Planck Society",
    "059mq0909",
    "novartis.com"
  ],
  "maxResultsPerQuery": 10,
  "maxConcurrency": 5,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "organizationType": ""
}
```

# Actor output Schema

## `dataset` (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": [
        "Siemens",
        "Max Planck Society",
        "059mq0909",
        "novartis.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/ror-research-organization-data").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": [
        "Siemens",
        "Max Planck Society",
        "059mq0909",
        "novartis.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/ror-research-organization-data").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 '{
  "queries": [
    "Siemens",
    "Max Planck Society",
    "059mq0909",
    "novartis.com"
  ]
}' |
apify call foxlabs/ror-research-organization-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/ror-research-organization-data"
        }
    }
}
```

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/rV7ne1Mt4xdGCvgd0/builds/MuLckAc5Da8hahQRR/openapi.json