# OpenAlex Institutions Scraper (`parseforge/openalex-institutions-scraper`) Actor

Scrapes OpenAlex institution records by search term, country, or type. Returns each institution as a flat row with display name, country, type, and works count.

- **URL**: https://apify.com/parseforge/openalex-institutions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### OpenAlex Institutions Scraper

**Scrape OpenAlex institution records by search term, country, or type, up to a million per run.** Each institution comes with its display name, country, type, and works count. No API key needed. Export to CSV, JSON, Excel, or XML.

OpenAlex's official API is free but you still need to write code, handle pagination, and shape the JSON. This reads the public institution index directly, filtered by search term, country, or institution type, and returns each match in one flat row. It is the fastest way to build a clean list of universities, companies, hospitals, and other research organizations.

| Who uses it | What they scrape OpenAlex for |
|---|---|
| Research analysts | Which institutions are most active in a field or region |
| University administrators | Benchmark their institution against peers by works count |
| Grant writers | Find potential partner institutions for a consortium |
| Data journalists | Map the geography of research output by institution |
| Recruiters | Identify companies and nonprofits that publish research |

### What it does

This Actor collects OpenAlex institution records by search term, country, or institution type, and returns each one as a flat row.

- 🔍 **Search by name:** full-text search on institution display name, e.g. 'Max Planck' or 'Stanford'.
- 🌍 **Country filter:** restrict to a single ISO 2-letter country code, e.g. 'de' for Germany.
- 🏛️ **Type filter:** choose from education, healthcare, company, archive, nonprofit, government, facility, or other.
- 📊 **Works count:** every record includes the total number of scholarly works linked to that institution.
- 📦 **Bulk export:** collect up to 1,000,000 institutions per run and export to CSV, JSON, Excel, or XML.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with OpenAlex data

**📈 Benchmark research output.**

A university strategy office pulls all education institutions in their country, sorts by works count, and sees where they rank.

**🗺️ Map the research landscape.**

A data journalist collects every institution in a region and builds a map of research activity by city and type.

**🤝 Find collaboration partners.**

A grant writer searches for nonprofit and healthcare institutions in a specific country to invite into a consortium.

**🏢 Identify corporate research.**

A recruiter filters for company institutions to find firms that publish scholarly work and might be hiring researchers.

**📚 Build a directory.**

A librarian collects all archive and facility institutions to create a public directory of research organizations.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | OpenAlex is free and open, and this Actor needs no registration or token. |
| **Flat rows** | Each institution is returned as a single row, ready for spreadsheets or databases. |
| **Bulk scale** | Collect up to a million institutions in one run, with automatic pagination. |
| **Clean filters** | Search, country, and type filters are applied server-side, so you only pay for matches. |

### How it compares

This Actor focuses on institution records, while the other OpenAlex scrapers on Apify are built for scholarly papers and citations.

| Feature | ParseForge | OpenAlex Academic Research Scraper - Scholarly Papers | OpenAlex Academic Research Scraper |
|---|---|---|---|
| Institution records only | Yes | Not listed | Not listed |
| Filter by institution type | Yes | Not listed | Not listed |
| Filter by country | Yes | Not listed | Not listed |
| Works count per institution | Yes | Not listed | Not listed |
| Scholarly paper search | Not listed | Yes | Yes |
| Citation analysis | Not listed | Yes | Yes |

### Configure the run

Drive the Actor from a search term, country code, and institution type, alone or together, and filters run as each record is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [OpenAlex Institutions Scraper](https://apify.com/parseforge/openalex-institutions-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to OpenAlex through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/openalex-institutions-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. If you set a country code, make sure it is a valid ISO 2-letter code in lowercase. If you set a type, make sure it is one of the allowed values. Also try a broader search term.

**Why is the run slow?**

OpenAlex rate-limits requests. The Actor respects these limits, so large collections can take time. Reduce maxItems or narrow your filters to speed things up.

**Can I get more than 1,000,000 institutions?**

The maximum is 1,000,000 per run. If you need more, split your query by country or type and run the Actor multiple times.

**Why do some institutions have missing country or type?**

OpenAlex may not have complete metadata for every institution. Missing values will appear as empty fields in your dataset.

**How do I search for institutions with special characters?**

Use the exact name or a substring. The search is full-text, so 'Université' will match institutions with that word. If you get no results, try a shorter or more common spelling.

### FAQ

| Question | Answer |
|---|---|
| Do I need an OpenAlex API key? | No. OpenAlex is a free, open scholarly database and this Actor uses its public API without authentication. |
| What is the maximum number of institutions I can collect? | You can set maxItems up to 1,000,000. The Actor will paginate through results until it reaches that number or the end of the list. |
| Can I filter by country? | Yes. Use the country input with an ISO 2-letter code in lowercase, for example 'us' for the United States or 'de' for Germany. |
| What institution types are available? | Education, healthcare, company, archive, nonprofit, government, facility, and other. Leave the type blank to include all types. |
| How do I search for a specific institution? | Enter a search term in the search input. It does a full-text search on the institution display name, so 'Max Planck' will return all Max Planck institutes. |
| What data does each institution record include? | Each record includes the institution's display name, country, type, works count, and other metadata from OpenAlex. The exact fields are shown in the sample output. |
| Can I export the results? | Yes. The Actor outputs a dataset that you can export to CSV, JSON, Excel, or XML from the Apify platform. |
| Is this the same as the OpenAlex Academic Research Scraper? | No. That Actor focuses on scholarly papers, authors, and citations. This Actor is specifically for institution records, with filters for country and type. |
| How fresh is the data? | OpenAlex updates its database continuously. Each run of this Actor fetches the latest data from the OpenAlex API. |
| Can I run this on a schedule? | Yes. You can schedule the Actor to run daily, weekly, or at any interval to keep your institution list up to date. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by OurResearch. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Full-text search on institution display name. Leave blank for all institutions sorted by works count.

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

Maximum number of institutions to collect per run.

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

Filter by ISO 2-letter country code (lowercase). Leave blank for any country.

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

Filter by institution type. Leave blank for any.

## Actor input object example

```json
{
  "maxItems": 10,
  "country": "",
  "type": ""
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openalex-institutions-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openalex-institutions-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 '{
  "maxItems": 10
}' |
apify call parseforge/openalex-institutions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/openalex-institutions-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/joP6lsMUm4xYJvv9g/builds/DTzuaDmkdHa13f8mJ/openapi.json