# NIH Grant Data by Organization — RePORTER Awards (`foxlabs/nih-reporter-organization-data`) Actor

Pull NIH-funded projects for any organization from NIH RePORTER. Returns project number, title, award amount, funding institute, fiscal year, project dates, department, principal investigators and the organization's city, state and country.

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

## Pricing

$3.00 / 1,000 award records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NIH Grant Data by Organization — RePORTER Awards 🧬

**foXLabs research-funding series:** [NSF awards](https://apify.com/foxlabs/nsf-awards-company-data) · [Clinical trial sponsors](https://apify.com/foxlabs/clinical-trial-sponsor-data) · [Research organizations (ROR)](https://apify.com/foxlabs/ror-research-organization-data) · [US nonprofits](https://apify.com/foxlabs/us-nonprofit-data) · [FDA drug sponsors](https://apify.com/foxlabs/fda-drug-sponsor-data)

🎉 See **which organizations win NIH money** — project title, award amount, funding institute, principal investigators and fiscal year — straight from NIH RePORTER, no key and no login.
Built for life-science sales teams, grant analysts, and anyone mapping biomedical research funding.

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

NIH RePORTER is the National Institutes of Health's public record of funded biomedical research. This Actor searches it by **recipient organization** and returns one clean row per project: what was funded, by which NIH institute, for how much, over which period, and which investigators lead it.

**Use it when you need:** every NIH project at a company, hospital or university; the NIH institute behind a grant; the named investigators to approach; or a funding profile of a target account before a sales conversation.

**Use something else when:** the funding is not biomedical — NSF covers general science and has its own record ([NSF Award Data](https://apify.com/foxlabs/nsf-awards-company-data)). For trials rather than grants, use [Clinical Trial Sponsors](https://apify.com/foxlabs/clinical-trial-sponsor-data).

### 🤖 Use with AI agents

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

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

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

```
Run the Apify actor foxlabs/nih-reporter-organization-data with
{"queries":["Mayo Clinic"],"maxResultsPerQuery":25}
and summarise the awards by NIH institute.
```

### 📋 Overview

| | |
|---|---|
| **Source** | NIH RePORTER (National Institutes of Health) |
| **Coverage** | NIH-funded projects at companies, hospitals and universities |
| **Auth needed** | None. No API key, no login, no proxy required |
| **Row** | One NIH project award |
| **Measured run** | 47 rows in 4.6 s for 3 organizations (2026-09-20, build 0.1.8) |
| **Pricing** | $0.003 per delivered row — $3 per 1,000 |

### ✨ Features

- 🏥 **Organization-first search** — type the recipient name, get their NIH projects
- 🏛️ **Funding institute named** on every row (e.g. National Human Genome Research Institute)
- 👥 **Principal investigators** listed per project
- 💵 **Award amount** and fiscal year on every row
- 🔗 **Core project number** — joins the yearly awards of one continuing project
- 🧪 **Award mechanism** (R01, U01, …) so you can filter by grant type
- ⚡ **Key-free and fast** — 47 rows in under 5 seconds, no proxy

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~nih-reporter-organization-data/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Genentech","Mayo Clinic"],"maxResultsPerQuery":25}'
```

### 🚀 Getting Started (3 steps)

1. **Name the organizations.** Put recipient names into `queries`. The default run searches `Genentech`, `Mayo Clinic` and `Regeneron Pharmaceuticals`.
2. **Narrow by year if you want.** `fiscalYears` limits results to specific NIH fiscal years.
3. **Run it.** Rows arrive in the dataset; export to CSV/JSON/Excel or read them over the API.

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["Genentech","Mayo Clinic","Regeneron Pharmaceuticals"]` | Recipient organization names |
| `fiscalYears` | array | `[]` | Limit to specific NIH fiscal years; empty means all |
| `maxResultsPerQuery` | integer | `25` | Cap on projects returned per organization |
| `maxConcurrency` | integer | `3` | Parallel requests against RePORTER |
| `requestDelayMs` | integer | `0` | Optional pause between requests |
| `includeRaw` | boolean | `false` | Attach the untouched RePORTER record to each row |
| `proxyConfiguration` | object | proxy off | RePORTER answers direct requests; enable only if you need it |

**Example — recent years only:**

```json
{ "queries": ["Mayo Clinic"], "fiscalYears": [2024, 2025], "maxResultsPerQuery": 100 }
```

**Example — several biotech companies:**

```json
{ "queries": ["Genentech", "Regeneron Pharmaceuticals", "Moderna"], "maxResultsPerQuery": 50 }
```

### 📤 Output

One row per project award. Fill rates below are from the measured run (47 rows, 3 organizations, 2026-09-20):

| Field | Type | Fill | Description |
|---|---|---|---|
| `companyName` | string | 100% | Recipient organization |
| `awardId` | string | 100% | NIH application id |
| `awardTitle` | string | 100% | Project title |
| `awardType` | string | 100% | Activity code (R01, U01, …) |
| `awardMechanism` | string | 100% | NIH funding mechanism |
| `coreProjectNumber` | string | 100% | Core project number — links a project's yearly awards |
| `counterparty` | string | 100% | NIH institute or centre funding the project |
| `amount` | number | 100% | Award amount |
| `currency` | string | 100% | Always `USD` |
| `fiscalYear` | number | 100% | NIH fiscal year |
| `principalInvestigators` | array | 100% | Named investigators on the project |
| `startDate` | string | 100% | Project start |
| `endDate` | string | 72% | Project end, where RePORTER publishes it |
| `companyId` | string | 72% | Recipient organization id, where published |
| `city` / `state` / `countryName` | string | 100% | Recipient location |
| `sourceUrl` | string | 100% | Official RePORTER project page |
| `source` / `query` / `scrapedAt` | string | 100% | Provenance fields |
| `department` | string | **0%** | RePORTER did not populate this on any row in the measured run — kept because the source defines the field, but treat it as usually empty |

Columns RePORTER does not publish at all (award date, status, industry code, free-text description) were removed rather than shipped permanently empty.

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

```json
{
  "companyName": "REGENERON PHARMACEUTICALS, INC.",
  "awardId": "1U01HG004085-01",
  "awardTitle": "Production of Targeted Null Mutations for 10,000 Genes in C57BL/6 ES Cells",
  "awardType": "U01",
  "counterparty": "National Human Genome Research Institute",
  "amount": 5311300,
  "currency": "USD",
  "fiscalYear": 2006,
  "startDate": "2006-09-07",
  "endDate": "2011-08-31",
  "city": "TARRYTOWN",
  "state": "NY"
}
```

### 💼 Use cases

- **Life-science sales** — find organizations with active NIH funding in your therapeutic area
- **Account research** — see how much NIH money a target account brings in, and from which institute
- **Investigator targeting** — reach the named PI on a relevant project
- **Competitive intelligence** — track a rival's publicly funded research programme
- **Market sizing** — group awards by institute, mechanism or fiscal year

### 🔗 Integration

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/nih-reporter-organization-data').call({
  queries: ['Mayo Clinic'], maxResultsPerQuery: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/nih-reporter-organization-data").call(
    run_input={"queries": ["Mayo Clinic"], "maxResultsPerQuery": 25}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

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

### 📊 Pricing

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

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

### ❓ FAQ

**Do I need an NIH API key?** No. RePORTER is public and this Actor needs no key, login or proxy.

**Does one project appear several times?** A continuing project is funded yearly, so each fiscal year is its own award row. `coreProjectNumber` groups them.

**Can I filter by year?** Yes — `fiscalYears`, e.g. `[2024, 2025]`.

**Why is `endDate` missing on some rows?** RePORTER does not publish a project end date on every record; it came back on 72% of rows in the measured run.

**Does it cover NSF or other agencies?** No — NIH only. Use [NSF Award Data](https://apify.com/foxlabs/nsf-awards-company-data) for NSF.

**Are the investigators personal data?** The PI names are published by NIH as part of the public funding record and are returned as published.

### 🐛 Troubleshooting

**An organization returns nothing.** RePORTER matches the recipient's registered name — try the formal spelling (`REGENERON PHARMACEUTICALS, INC.`).

**Too many rows for one organization.** Large hospitals hold hundreds of projects. Lower `maxResultsPerQuery` or narrow with `fiscalYears`.

**Amounts look inconsistent year to year.** NIH funds continuing projects in yearly increments; use `coreProjectNumber` to total a project across years.

### ⚠️ Trademark

The National Institutes of Health is a US federal agency. This Actor is an independent tool, is not affiliated with or endorsed by NIH or the US Government, and reads only publicly published award records.

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

NIH RePORTER exists so the public can see how federal biomedical research money is spent. The rows this Actor returns describe organizations and funded projects; investigator names appear exactly as NIH publishes them in that public record. You remain responsible for how you use the output.

### 🤝 Support & contact

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

### Changelog

#### 0.1.8

- **Removed permanently-empty columns** (`awardedOn`, `status`, `industryCode`, `description`) — RePORTER does not publish them, so they no longer ship as null. Row went from 27 columns to 22, of which 20 are populated on every measured row.

#### 0.1

- NIH RePORTER search by recipient organization, one row per project award.
- Pay-per-event billing on delivered rows (`award-record`).

# Changelog

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

# Actor input Schema

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

Awardee organization names (`Genentech`, `Mayo Clinic`, `Amgen`). RePORTER matches the name as registered on the grant, so a holding-company name often returns nothing while the operating entity returns everything.

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

How many rows a single query may produce.

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

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

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

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

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

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

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

Optional. RePORTER is an open federal API and rarely needs a proxy.

## `fiscalYears` (type: `array`):

Limit to specific NIH fiscal years, e.g. 2024, 2025. Leave empty for all years.

## Actor input object example

```json
{
  "queries": [
    "Genentech",
    "Mayo Clinic",
    "Regeneron Pharmaceuticals"
  ],
  "maxResultsPerQuery": 25,
  "maxConcurrency": 3,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "fiscalYears": []
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "Genentech",
        "Mayo Clinic",
        "Regeneron Pharmaceuticals"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/nih-reporter-organization-data").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        "Genentech",
        "Mayo Clinic",
        "Regeneron Pharmaceuticals",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/nih-reporter-organization-data").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "Genentech",
    "Mayo Clinic",
    "Regeneron Pharmaceuticals"
  ]
}' |
apify call foxlabs/nih-reporter-organization-data --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Da5pQ6CYMZe7RbyXv/builds/CJ9jgzdSXrLbpr0xR/openapi.json