# NIH RePORTER Grant Scraper - Funding, PI & Award Data (`themineworks/nih-reporter-grants`) Actor

Scrape NIH RePORTER grants: title, abstract, award $, principal investigator, institution, agency (NCI, NIAID, NIMH), fiscal year. 800K+ grants, no API key. Use in Claude, ChatGPT & any MCP agent.

- **URL**: https://apify.com/themineworks/nih-reporter-grants.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Business, Developer tools, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 grant scrapeds

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

## NIH RePORTER — Grant Funding Search ($47B Portfolio)

Search the full NIH Research Portfolio Online Reporting Tools (RePORTER) database from Apify. Access 800,000+ active and historical NIH grant records — project titles, abstracts, award amounts, principal investigators, institutions, funding agencies, and fiscal years — all without an API key.

### Why This Actor?

The National Institutes of Health distributes over **$47 billion** in research grants annually across 27 institutes and centers. Understanding where that money flows is critical intelligence for:

- **Pharma business development teams** scouting academic partners, licensing targets, and competitive research pipelines
- **Biotech investors** identifying early-stage research funded before IP is publicly visible
- **Academic grant writers** benchmarking award sizes, finding funding trends, and discovering peer PI activity
- **Policy researchers and journalists** tracking government spending priorities across disease areas
- **AI/ML teams** building biomedical knowledge graphs and literature pipelines

Until now, accessing this data at scale meant wrestling with NIH's web interface, limited exports, or manually paging through results. This actor wraps the official **NIH RePORTER REST API v2** (`api.reporter.nih.gov/v2`) into a clean, paginated scraper that delivers structured JSON to your Apify dataset.

### What the API Covers

The NIH RePORTER API indexes grants from all major NIH institutes:

- **NCI** — National Cancer Institute
- **NIAID** — National Institute of Allergy and Infectious Diseases
- **NIMH** — National Institute of Mental Health
- **NHLBI** — National Heart, Lung, and Blood Institute
- **NHGRI** — National Human Genome Research Institute
- **NIDDK** — National Institute of Diabetes and Digestive and Kidney Diseases
- **NIA** — National Institute on Aging
- **NINDS** — National Institute of Neurological Disorders and Stroke
- **NCCIH** — National Center for Complementary and Integrative Health

Grants include R01, R21, P01, U01, SBIR/STTR, and training awards. Records go back to fiscal year 1985 and are updated weekly.

### Inputs

| Field | Type | Description | Default |
|---|---|---|---|
| `searchTerms` | string | Keywords to search in title and abstract (e.g. `mRNA vaccine`, `Alzheimer`, `CRISPR`) | `mRNA vaccine` |
| `agency` | string | NIH agency code: `NCI`, `NIAID`, `NIMH`, `NHLBI`, etc. Leave blank for all agencies | — |
| `fiscalYear` | integer | Grant fiscal year (e.g. `2024`). Leave blank for 2023–2025 | — |
| `state` | string | Filter by PI institution state (2-letter code, e.g. `CA`, `NY`) | — |
| `minAward` | integer | Return only grants above this dollar amount | — |
| `maxResults` | integer | Maximum grants to return (1–5,000) | `100` |

### Output Format

Each grant is stored as one item in the Apify dataset:

```json
{
  "project_number": "5R01CA123456-03",
  "title": "Novel mRNA Vaccine Platforms for Pancreatic Cancer",
  "abstract": "We propose to develop and evaluate...",
  "fiscal_year": 2024,
  "award_amount_usd": 412500,
  "funding_agency": "NCI",
  "principal_investigators": ["Jane Smith", "Robert Chen"],
  "institution": "JOHNS HOPKINS UNIVERSITY",
  "institution_city": "Baltimore",
  "institution_state": "MD",
  "terms": "mRNA; Vaccine; Pancreatic Neoplasms; KRAS",
  "url": "https://reporter.nih.gov/project-details/5R01CA123456-03",
  "scraped_at": "2024-11-15T09:22:11.000Z"
}
````

A summary record is appended at the end with total grant count and run timestamp.

### Pricing

**First 25 results are free** on every Apify account — no charge until you exceed the free tier.

After the free tier: **$6 per 1,000 grants** (Pay-Per-Event billing). A 1,000-grant run costs $6.00. A 5,000-grant run costs $30.00. You are charged only for results actually delivered — if the API returns fewer results than requested, you pay only for what you received.

### Frequently Asked Questions

**Q: Do I need an NIH API key?**
No. The NIH RePORTER API is fully public and does not require authentication. This actor works out of the box.

**Q: How current is the data?**
NIH updates RePORTER weekly. You will typically see grants funded within the last 7–14 days. The API does not provide real-time data.

**Q: Can I filter by multiple agencies at once?**
The current version accepts one agency code per run. To search across multiple agencies, run the actor once per agency and merge the datasets downstream, or leave the `agency` field blank to retrieve results from all agencies simultaneously.

**Q: What is the difference between `searchTerms` and the `agency` filter?**
`searchTerms` performs a full-text search across project titles and MeSH/keyword terms. `agency` is an exact match on the funding institute abbreviation. Both filters are ANDed together when both are provided.

**Q: Can I retrieve abstracts in bulk for NLP or AI training?**
Yes. The `abstract` field is returned for every grant record. Set `maxResults` up to 5,000 per run. For larger volumes, run multiple times with different `searchTerms` or `fiscalYear` filters and deduplicate by `project_number`.

**Q: How does the free tier work across multiple runs?**
The 25 free results are tracked per Apify account using a persistent key-value store. Once exhausted, subsequent results are charged at the Pay-Per-Event rate. Free results do not reset between runs.

**Q: What grant types are included?**
All NIH grant mechanisms are indexed: R01 (research project), R21 (exploratory), P01 (program project), U01 (cooperative agreement), SBIR (R43/R44), STTR (R41/R42), K awards (career development), T awards (training), and others. Use the `searchTerms` field with mechanism codes if you need to target a specific type.

**Q: Is the award amount the total project cost or the direct cost?**
The `award_amount_usd` field reflects the **total cost** for that fiscal year (direct costs plus indirect/facilities costs), as reported by NIH RePORTER.

### Use in Claude, ChatGPT & any MCP agent

This actor is also a **Model Context Protocol (MCP) server tool** — call it directly from Claude, ChatGPT, Cursor, Windsurf, or any MCP-compatible AI agent. The agent only pays for results delivered (same pay-per-result model).

- Per-actor MCP endpoint: `https://mcp.apify.com/?tools=themineworks/nih-reporter-grants`
- Full Mine Works MCP server (all tools): `https://the-mine-works-mcp.hatchable.site/api/mcp`

```js
// Call this actor as a tool via apify-client (Node)
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('themineworks/nih-reporter-grants').call({ /* input from the table above */ });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

# Actor input Schema

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

Terms to search in title and abstract (e.g. mRNA vaccine, Alzheimer, CRISPR).

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

NIH agency code: NCI, NIAID, NIMH, NHLBI, NHGRI, NIDDK, NIA, NINDS, NCCIH, etc. Leave blank for all agencies.

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

Grant fiscal year (e.g. 2024, 2023). Leave blank for 2023-2025.

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

Filter by PI institution state.

## `minAward` (type: `integer`):

Return only grants above this total award amount.

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

Maximum grants to return.

## Actor input object example

```json
{
  "searchTerms": "mRNA vaccine",
  "maxResults": 25
}
```

# 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 = {
    "searchTerms": "mRNA vaccine",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/nih-reporter-grants").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 = {
    "searchTerms": "mRNA vaccine",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/nih-reporter-grants").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 '{
  "searchTerms": "mRNA vaccine",
  "maxResults": 25
}' |
apify call themineworks/nih-reporter-grants --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Grant Scraper - Funding, PI & Award Data",
        "description": "Scrape NIH RePORTER grants: title, abstract, award $, principal investigator, institution, agency (NCI, NIAID, NIMH), fiscal year. 800K+ grants, no API key. Use in Claude, ChatGPT & any MCP agent.",
        "version": "0.1",
        "x-build-id": "meB2GTapzWFD6TiVD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~nih-reporter-grants/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-nih-reporter-grants",
                "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/themineworks~nih-reporter-grants/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-nih-reporter-grants",
                "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/themineworks~nih-reporter-grants/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-nih-reporter-grants",
                "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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "string",
                        "description": "Terms to search in title and abstract (e.g. mRNA vaccine, Alzheimer, CRISPR)."
                    },
                    "agency": {
                        "title": "Funding agency",
                        "type": "string",
                        "description": "NIH agency code: NCI, NIAID, NIMH, NHLBI, NHGRI, NIDDK, NIA, NINDS, NCCIH, etc. Leave blank for all agencies."
                    },
                    "fiscalYear": {
                        "title": "Fiscal year",
                        "type": "integer",
                        "description": "Grant fiscal year (e.g. 2024, 2023). Leave blank for 2023-2025."
                    },
                    "state": {
                        "title": "Institution state (2-letter)",
                        "type": "string",
                        "description": "Filter by PI institution state."
                    },
                    "minAward": {
                        "title": "Minimum award ($)",
                        "type": "integer",
                        "description": "Return only grants above this total award amount."
                    },
                    "maxResults": {
                        "title": "Max grants",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum grants to return.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```