# ROR Research Organization Registry Scraper — Institutions API (`compute-edge/ror-research-orgs-scraper`) Actor

Extract research organizations from ROR (Research Organization Registry), 124k+ institutions worldwide. Filter by query, country, and type. Returns name, type, country, city, coordinates, homepage, aliases, and GRID/ISNI/FundRef/Wikidata IDs for research intelligence and enrichment.

- **URL**: https://apify.com/compute-edge/ror-research-orgs-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Extract structured data from the **Research Organization Registry (ROR)** — the authoritative global registry of 124,000+ research institutions, universities, hospitals, and research centers maintained by the Community Organizations for Research Excellence (CORE) and supported by major research institutions worldwide.

This Actor provides complete access to ROR's free, open API with powerful filtering by organization type, country, and full-text search. Output includes geographic coordinates, external identifiers (GRID, ISNI, Wikidata), and relationship metadata — clean JSON ready for research databases, institutional networks, or academic analysis pipelines.

### Key Features

- **Complete ROR coverage** — 124,000+ research institutions from 185+ countries
- **Full-text search** — Find organizations by name, keyword, or acronym (e.g., "Harvard", "MIT", "Max Planck")
- **Country filtering** — Filter by country name or 2-letter ISO code (e.g., "United States", "DE", "JP")
- **Organization type filtering** — Isolate specific sectors: Education, Healthcare, Company, Government, Nonprofit, Facility, Archive
- **Geographic data** — City, latitude, longitude, and country code for mapping and geospatial analysis
- **External identifiers** — GRID, ISNI, FundRef, and Wikidata IDs for cross-referencing with other databases
- **Relationship counts** — Number of affiliated organizations for network analysis
- **Establishment year** — Historical founding data for institutional analysis
- **No authentication required** — Free public ROR API, no keys or credentials needed
- **Batch-optimized output** — Clean JSON ready for RAG pipelines, research databases, or institutional networks

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | ROR persistent identifier (e.g., https://ror.org/01a9mp70) |
| `name` | string | Official organization name |
| `types` | string | Organization type(s), comma-separated (e.g., "Education, Nonprofit") |
| `established` | integer | Year the organization was founded (null if unknown) |
| `status` | string | Current status (e.g., "active", "inactive") |
| `countryCode` | string | ISO 2-letter country code (e.g., "US", "GB", "DE") |
| `countryName` | string | Full country name (e.g., "United States", "Germany") |
| `city` | string | Primary city location |
| `latitude` | number | Latitude coordinate for mapping |
| `longitude` | number | Longitude coordinate for mapping |
| `homepage` | string | Official website URL |
| `aliases` | string | Alternative names used by the organization, comma-separated |
| `acronyms` | string | Known acronyms, comma-separated (e.g., "MIT", "NIH") |
| `wikipediaUrl` | string | Wikipedia article URL if available |
| `grid` | string | GRID identifier for cross-reference with other databases |
| `isni` | string | ISNI (International Standard Name Identifier) |
| `fundref` | string | Funder ID from CrossRef's Funder Registry |
| `wikidata` | string | Wikidata entity ID (QID) |
| `numRelationships` | integer | Count of affiliated organizations or parent/subsidiary relationships |

### How to Scrape ROR Organizations

1. Navigate to the **ROR Research Organization Registry Scraper** on Apify Store.
2. Click **Start** to open the input configuration form.
3. (Optional) Enter a **Full-Text Search Query** to find specific organizations (e.g., "Harvard Medical School").
4. (Optional) Enter a **Country Filter** by name or code (e.g., "France" or "FR").
5. (Optional) Enter an **Organization Type** (e.g., "Education", "Healthcare", "Government").
6. Set **Max Results** to control output size (default: 1000, set to 0 for unlimited).
7. Click **Start** to run the Actor.
8. Download results as JSON, CSV, or Excel from the **Dataset** tab.

### Input Examples

#### Example 1: Universities in the United States
```json
{
    "country": "United States",
    "type": "Education",
    "maxResults": 500
}
````

#### Example 2: Search for MIT and related institutions

```json
{
    "query": "MIT",
    "maxResults": 50
}
```

#### Example 3: Healthcare organizations in Germany

```json
{
    "country": "DE",
    "type": "Healthcare",
    "maxResults": 200
}
```

### Output Example

```json
{
    "id": "https://ror.org/01a9mp70",
    "name": "Massachusetts Institute of Technology",
    "types": "Education",
    "established": 1861,
    "status": "active",
    "countryCode": "US",
    "countryName": "United States",
    "city": "Cambridge, Massachusetts",
    "latitude": 42.3601,
    "longitude": -71.0589,
    "homepage": "https://www.mit.edu",
    "aliases": "MIT",
    "acronyms": "MIT",
    "wikipediaUrl": "https://en.wikipedia.org/wiki/Massachusetts_Institute_of_Technology",
    "grid": "grid.4991.5",
    "isni": "0000 0001 2341 6899",
    "fundref": "501100002341",
    "wikidata": "Q49108",
    "numRelationships": 12
}
```

### Pricing

This Actor fetches data from a free public API with efficient pagination. Compute costs are minimal.

- **Cost per run**: ~$0.001 (minimal API calls)
- **Actor start event**: Default platform rate
- **Per-result pricing**: $0.003/result

Typical run time is 10-30 seconds depending on result count and filters.

### Use Cases

- **Research network mapping** — Analyze collaboration networks and institutional relationships
- **Academic database enrichment** — Cross-reference organizations with GRID, ISNI, Wikidata, and other databases
- **Grant research** — Identify research institutions by country, type, and funding organization
- **Institutional analysis** — Map research capacity by geography and sector
- **Educational analytics** — Build datasets of universities for enrollment, ranking, or program analysis
- **Healthcare research** — Extract hospital and healthcare institution directories by country
- **Government database** — Track public research institutions and government research centers
- **Institutional affiliations** — Validate researcher and author institutional data against authoritative source
- **Geospatial research** — Use coordinates for mapping research capacity and institutional density
- **RAG pipeline ingestion** — Clean structured output ready for LLM-based research analysis

### Legal & Attribution

- **License**: ROR data is made available under the [Community Data License Agreement (CDLA) 2.0 Sharing](https://www.cdla.dev/sharing-2-0-legalcode)
- **Attribution**: This scraper accesses the free, public ROR API. Data sourced from https://ror.org/
- **Terms of Service**: Scraping is permitted by ROR's license and API terms of service for research and educational purposes
- **Usage rights**: The data can be used, shared, and modified for research, educational, and non-profit purposes with attribution

**Disclaimer**: This Actor scrapes only publicly accessible, non-personal research organization data. Users are responsible for complying with the ROR license terms and their local data usage regulations. This tool is provided for legitimate research and educational purposes.

### FAQ

**Q: What is ROR?**
A: The Research Organization Registry (ROR) is a global, community-driven registry of research organizations maintained by CORE, Crossref, and DataCite. It provides persistent, unique identifiers and metadata for 124,000+ research institutions.

**Q: Can I search by organization type?**
A: Yes. The Actor supports filtering by type: Education, Healthcare, Company, Government, Nonprofit, Facility, Archive.

**Q: What's the difference between GRID, ISNI, and Wikidata IDs?**
A: These are different persistent identifier systems used by different research infrastructure platforms. GRID is widely used in academic databases, ISNI is an international standard for names, and Wikidata is a collaborative knowledge base.

**Q: Can I get all 124,000+ organizations in one run?**
A: Yes. Set `maxResults` to 0 for unlimited results. The Actor will paginate through all available data. This may take 2-5 minutes depending on API response time.

**Q: Are coordinates always available?**
A: Most organizations have coordinates available. If not, the `latitude` and `longitude` fields will be empty strings.

**Q: What happens if I search with multiple filters?**
A: The Actor applies all filters together (AND logic). For example, searching for "Education" type in "United States" will return only educational institutions in the US.

### Support

For issues, feature requests, or questions about this Actor, please contact the developer or post on Apify Community Forums.

# Actor input Schema

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

Optional: Search for organizations by name or keyword. Examples: 'Harvard', 'MIT', 'Stanford', 'National Cancer Institute'.

## `country` (type: `string`):

Optional: Filter by country name or 2-letter country code. Examples: 'United States', 'UK', 'Germany', 'FR' (France), 'JP' (Japan).

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

Optional: Filter by organization type. Examples: 'Education', 'Healthcare', 'Company', 'Government', 'Nonprofit', 'Facility', 'Archive'.

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

Maximum number of organizations to return. Set to 0 for unlimited (up to available). Default: 1000.

## Actor input object example

```json
{
  "query": "",
  "country": "",
  "type": "",
  "maxResults": 1000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/ror-research-orgs-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/ror-research-orgs-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 '{}' |
apify call compute-edge/ror-research-orgs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ROR Research Organization Registry Scraper — Institutions API",
        "description": "Extract research organizations from ROR (Research Organization Registry), 124k+ institutions worldwide. Filter by query, country, and type. Returns name, type, country, city, coordinates, homepage, aliases, and GRID/ISNI/FundRef/Wikidata IDs for research intelligence and enrichment.",
        "version": "0.1",
        "x-build-id": "rVD892KVLodewWwoO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~ror-research-orgs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-ror-research-orgs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/compute-edge~ror-research-orgs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-ror-research-orgs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/compute-edge~ror-research-orgs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-ror-research-orgs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Full-Text Search Query",
                        "type": "string",
                        "description": "Optional: Search for organizations by name or keyword. Examples: 'Harvard', 'MIT', 'Stanford', 'National Cancer Institute'.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country Filter",
                        "type": "string",
                        "description": "Optional: Filter by country name or 2-letter country code. Examples: 'United States', 'UK', 'Germany', 'FR' (France), 'JP' (Japan).",
                        "default": ""
                    },
                    "type": {
                        "title": "Organization Type",
                        "type": "string",
                        "description": "Optional: Filter by organization type. Examples: 'Education', 'Healthcare', 'Company', 'Government', 'Nonprofit', 'Facility', 'Archive'.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of organizations to return. Set to 0 for unlimited (up to available). Default: 1000.",
                        "default": 1000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
