# NIH RePORTER Scraper (`parseforge/nih-reporter-scraper`) Actor

Scrape NIH research grant awards with 40+ fields per project. Get funding amounts, principal investigators, institutions, abstracts, spending categories, and geo coordinates. Filter by keyword, fiscal year, agency, and active status.

- **URL**: https://apify.com/parseforge/nih-reporter-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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/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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🔬 NIH RePORTER Scraper

Whether you're a researcher tracking grant funding, a university monitoring NIH awards, or an analyst studying federal health research investments, this tool makes it easy to collect structured project data from the NIH RePORTER database.

> **The NIH RePORTER Scraper collects research grant data including project titles, funding amounts, investigators, organizations, activity codes, and spending categories. Filter by keyword, fiscal year, agency, and active status.**

### What Does It Do

- 📋 **Project listings** - collect project titles, numbers, activity codes, and funding mechanisms across thousands of NIH-funded studies
- 💰 **Funding details** - extract total award amounts, direct costs, and indirect costs for each project
- 👨‍🔬 **Investigator data** - get principal investigator names, contact PIs, and full research teams
- 🏛️ **Organization info** - retrieve institution names, cities, states, countries, and organization types
- 🔍 **Keyword search** - find projects matching specific research terms like "cancer", "diabetes", or "machine learning"
- 📅 **Date tracking** - capture project start/end dates, budget periods, and award notice dates

### Input

- **Keyword** - search for projects containing specific research terms (e.g., "cancer", "genomics", "clinical trial")
- **Max Items** - how many projects to collect (free users get 10 items, paid users up to 1,000,000)
- **Fiscal Year** - filter by fiscal year (e.g., 2024, 2023)
- **Agency Code** - filter by NIH institute (e.g., "NCI", "NIMH", "NIAID", "NHLBI")
- **Active Projects Only** - only return currently active projects

```json
{
    "keyword": "cancer",
    "maxItems": 50,
    "fiscalYear": 2024,
    "agencyCode": "NCI",
    "isActive": true
}
````

### Output

Each project record includes 35+ data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| projectDetailUrl | Project detail page on NIH RePORTER |
| projectTitle | Title of the research project |
| projectNum | Full project number |
| awardAmount | Total award amount in dollars |
| directCostAmt | Direct cost amount |
| indirectCostAmt | Indirect cost amount |
| contactPiName | Contact principal investigator |
| piNames | All principal investigators |
| orgName | Recipient organization name |
| orgState | Organization state |
| activityCode | Activity code (R01, U01, etc.) |
| agencyCode | Funding NIH institute code |
| fiscalYear | Fiscal year of the award |
| projectStartDate | Project start date |
| projectEndDate | Project end date |
| abstractText | Project abstract/summary |
| spendingCategories | Research spending categories |
| isActive | Whether the project is currently active |

```json
{
    "applId": 10856789,
    "projectNum": "5R01CA123456-05",
    "projectTitle": "Novel Biomarkers for Early Cancer Detection",
    "awardAmount": 450000,
    "directCostAmt": 300000,
    "indirectCostAmt": 150000,
    "contactPiName": "SMITH, JOHN A",
    "piNames": "SMITH, JOHN A; DOE, JANE B",
    "orgName": "JOHNS HOPKINS UNIVERSITY",
    "orgCity": "BALTIMORE",
    "orgState": "MD",
    "orgCountry": "UNITED STATES",
    "activityCode": "R01",
    "agencyCode": "NCI",
    "fiscalYear": 2024,
    "projectStartDate": "2020-07-01T00:00:00",
    "projectEndDate": "2025-06-30T00:00:00",
    "isActive": true,
    "projectDetailUrl": "https://reporter.nih.gov/project-details/10856789",
    "scrapedAt": "2026-04-09T12:00:00.000Z"
}
```

### Why Choose the NIH RePORTER Scraper?

| Feature | Our Tool | Manual NIH RePORTER Search |
|---------|----------|---------------------------|
| Batch collection | Up to 1M projects | Browse one page at a time |
| Keyword filtering | Full-text search across terms | Limited search interface |
| Structured output | JSON, CSV, Excel | HTML pages only |
| Automated scheduling | Daily/weekly monitoring | Manual visits |
| Funding analysis | Award amounts ready for analysis | Copy-paste from each page |
| Investigator data | All PIs in structured format | Scattered across pages |

### How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your keyword, fiscal year, agency, and how many projects you want
3. **Run It** - click "Start" and get structured grant data in seconds

No coding, no setup, no manual browsing required.

### Business Use Cases

- 🎓 **Universities** - track NIH funding awarded to your institution and competitors across all departments
- 🔬 **Researchers** - find active projects in your field to identify collaborators and avoid duplication
- 📊 **Grant analysts** - study funding trends by agency, activity code, and spending category over time
- 🏥 **Biotech companies** - monitor federally funded research that could lead to licensing or partnership opportunities
- 🏛️ **Policy analysts** - analyze how NIH distributes funds across states, institutions, and research areas
- 💼 **Consulting firms** - build competitive intelligence on which organizations receive the most NIH funding

### FAQ

🔬 **What is NIH RePORTER?**
NIH RePORTER is the official searchable database of NIH-funded research projects. It covers billions of dollars in annual biomedical research grants across all NIH institutes and centers.

🏛️ **What agency codes can I use?**
Common codes include: NCI (Cancer), NIMH (Mental Health), NIAID (Allergy/Infectious Disease), NHLBI (Heart/Lung/Blood), NINDS (Neurological Disorders), NIGMS (General Medical Sciences), NIDDK (Diabetes/Digestive/Kidney).

📋 **What activity codes are included?**
The data includes all NIH activity codes such as R01 (Research Project Grant), U01 (Cooperative Agreement), K08 (Clinical Investigator Award), T32 (Training Grant), and many more.

**How long does a run take?**
About 1-2 seconds per 500 projects. A full run of 10,000 projects typically finishes in under 30 seconds.

📅 **How often is NIH data updated?**
NIH RePORTER data is updated regularly. Set up a scheduled run to monitor for new awards weekly or monthly.

### Integrate NIH RePORTER Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate grant monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new grants match your criteria
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export grant data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### Recommended Actors

Looking for more government and research data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| GSA eLibrary Scraper | Collect government contract data from GSA | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| USASpending Scraper | Gather federal spending and award data | [Link](https://apify.com/parseforge/usaspending-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to NIH, NIH RePORTER, the National Institutes of Health, or the U.S. Department of Health and Human Services. It accesses only publicly available data.

# Actor input Schema

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

Search keyword for NIH research projects (searches in terms field)

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `fiscalYear` (type: `integer`):

Fiscal year to search for projects

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

Optional NIH agency code filter (e.g., 'NCI', 'NIMH', 'NIAID')

## `isActive` (type: `boolean`):

Only return currently active projects

## Actor input object example

```json
{
  "keyword": "cancer",
  "maxItems": 10,
  "fiscalYear": 2024,
  "isActive": true
}
```

# 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 = {
    "keyword": "cancer",
    "maxItems": 10,
    "fiscalYear": 2024
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nih-reporter-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 = {
    "keyword": "cancer",
    "maxItems": 10,
    "fiscalYear": 2024,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/nih-reporter-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Scraper",
        "description": "Scrape NIH research grant awards with 40+ fields per project. Get funding amounts, principal investigators, institutions, abstracts, spending categories, and geo coordinates. Filter by keyword, fiscal year, agency, and active status.",
        "version": "0.0",
        "x-build-id": "JfCSwQxyhGbZSpPY4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nih-reporter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nih-reporter-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/parseforge~nih-reporter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nih-reporter-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/parseforge~nih-reporter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nih-reporter-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",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search keyword for NIH research projects (searches in terms field)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "fiscalYear": {
                        "title": "Fiscal Year",
                        "type": "integer",
                        "description": "Fiscal year to search for projects"
                    },
                    "agencyCode": {
                        "title": "Agency Code",
                        "type": "string",
                        "description": "Optional NIH agency code filter (e.g., 'NCI', 'NIMH', 'NIAID')"
                    },
                    "isActive": {
                        "title": "Active Projects Only",
                        "type": "boolean",
                        "description": "Only return currently active projects",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
