# Grants.gov Scraper: Federal Grants, NIH & NSF Awards API (`pandadad0214/grants-finder`) Actor

Use this to find US federal funding: open and forecasted Grants.gov opportunities plus funded NIH and NSF awards (Grants.gov scraper). Input: keywords plus agency, date and amount filters. Output: one row per grant with agency, dates, amount (USD), eligibility and link.

- **URL**: https://apify.com/pandadad0214/grants-finder.md
- **Developed by:** [Panda Federation](https://apify.com/pandadad0214) (community)
- **Categories:** Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

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

## Grants.gov Scraper: Federal Grants, NIH & NSF Awards API

> **Grants.gov scraper** on Apify: search open and forecasted federal grant opportunities on Grants.gov plus funded NIH RePORTER and NSF awards in one run, exported to Excel, CSV and JSON. Apify's free plan includes $5 of monthly platform credit, enough for roughly 1,666 grants at $0.003 each (pricing below).

**Find federal funding in one run. Get open and upcoming Grants.gov opportunities, plus NIH and NSF awards already made, as one clean table with deadline, award ceiling, eligibility, summary and official link, and download it as Excel or CSV.**

Grant research usually means three websites, three search forms and a lot of copy-pasting. **Grants Finder** queries the **official public APIs** of **Grants.gov**, **NIH RePORTER** and **NSF Award Search** in parallel, normalizes every record into the same columns and hands you a spreadsheet you can filter, share or load into a CRM.

- 🎯 **Open opportunities from Grants.gov:** forecasted and posted funding calls with close date, award ceiling and floor, total program funding, expected number of awards, applicant eligibility, funding instrument, assistance listing (CFDA) and the agency contact
- 🧬 **NIH RePORTER awards:** who got funded, by which institute, for how much, project dates, principal investigator, activity code and the funding opportunity (FOA) it came from. Each project appears once, not once per fiscal year
- 🔬 **NSF awards:** estimated total award, start and end dates, recipient institution, PI, directorate and program
- 🔎 **One set of filters for all three:** keywords, agencies (codes, institutes or directorates), date range and amount range
- 📊 **Excel + CSV export:** formatted workbook with clickable links, a search log sheet and per-source counts
- 🚫 **Nothing guessed:** when a source doesn't publish a field, the cell stays empty
- 💸 **$0.003 per result.** 150 results cost $0.45. Searches with no results cost nothing

### Who it's for

- **Grant writers and development consultants:** a weekly list of open calls that fit a client, with deadlines and ceilings side by side
- **Research offices and university administrators:** spot new opportunities and see which programs fund work like yours
- **Nonprofits, startups and SBIR/STTR applicants:** check eligibility and amounts before investing in an application
- **Analysts, journalists and BD teams:** track who is funded in a field, by whom and for how much

> **Not for coursework.** Grants Finder finds and organizes public funding records. It doesn't write proposals, and it isn't meant for completing assignments on someone else's behalf. Always confirm deadlines and eligibility on the official page before applying.

### How to use the Grants.gov scraper

1. Click **Try for free** and type your **keywords** (use quotes for exact phrases, e.g. `"machine learning" agriculture`).
2. Pick the **sources**. Grants.gov = opportunities you can apply to; NIH and NSF = awards already made.
3. Optional: add **agencies**, a **date range** or an **amount range**.
4. Set **Maximum results per source**. You pay per returned result, so this also caps the cost.
5. Click **Start**. A 150-row run usually takes under a minute. Download **GRANTS_XLSX** or **GRANTS_CSV** from **Storage → Key-value store**, or use the dataset via API.

#### Input example

```json
{
  "keywords": "artificial intelligence",
  "sources": ["grants_gov", "nih", "nsf"],
  "maxResultsPerSource": 25,
  "dateFrom": "2025-01-01",
  "minAmount": 100000
}
```

#### Agency filter cheat sheet

| Source | What to type | Examples |
|---|---|---|
| Grants.gov | Agency code, code prefix or part of the name | `HHS-NIH11`, `HHS` (all HHS), `DOE`, `USDA`, `ED`, `NSF`, `Geological Survey` |
| NIH RePORTER | Institute abbreviation, or `NIH` for all | `NCI`, `NIAID`, `NIMH`, `NHLBI`, `NIGMS` |
| NSF | Directorate, or `NSF` for all | `CSE`, `BIO`, `GEO`, `MPS`, `SBE`, `EDU`, `ENG`, `TIP` |

A source is skipped when none of its agencies are in the list, so `["NCI"]` searches only NIH, and `["DOE", "NSF"]` searches Grants.gov and NSF.

### Output example

![Example output table from a real grants-finder run](https://api.apify.com/v2/key-value-stores/0eeXxTD8eJjgE6yTA/records/shot-grants-finder)

One row per opportunity or award. Real rows from a run of the input above (75 results: 25 per source; summaries shortened):

```json
{
  "rank": 1,
  "source": "Grants.gov",
  "recordType": "opportunity",
  "status": "posted",
  "title": "Cooperative Agreement for Affiliated Partner with the Great Lakes-Northern Forest Cooperative Ecosystem Studies Unit (CESU)",
  "agency": "Geological Survey",
  "agencyCode": "DOI-USGS1",
  "number": "G27AS00079",
  "openDate": "2026-10-14",
  "closeDate": "2026-11-14",
  "amount": 150000,
  "amountType": "award ceiling",
  "totalProgramFunding": 150000,
  "expectedAwards": 1,
  "eligibility": "Others (see text field entitled \"Additional Information on Eligibility\" for clarification) | … Eligible recipients must be a participating partner of the Great Lakes-Northern Forest CESU Program.",
  "summary": "The U.S. Geological Survey (USGS) is offering a funding opportunity to a CESU partner for research in … national-scale biogeographic information for fish and other aquatic organisms…",
  "fundingInstrument": "Cooperative Agreement",
  "url": "https://www.grants.gov/search-results-detail/364075"
}
```

```json
{
  "source": "NSF Award Search",
  "recordType": "award",
  "status": "active",
  "title": "EPSCoR Graduate Fellowship Program (EGFP): Boise State Microelectronics Education and Research Fellows",
  "agency": "NSF / Scholarships, Fellowships, and Traineeships Section",
  "number": "2535466",
  "openDate": "2027-03-15",
  "closeDate": "2030-02-28",
  "amount": 954000,
  "amountType": "estimated total award",
  "recipient": "Boise State University (BOISE, ID)",
  "principalInvestigator": "Todd P Otanicar",
  "url": "https://www.nsf.gov/awardsearch/showAward?AWD_ID=2535466"
}
```

#### Fields

| Field | Grants.gov | NIH RePORTER | NSF |
|---|---|---|---|
| `source`, `recordType` | Grants.gov, opportunity / forecast | NIH RePORTER, award | NSF Award Search, award |
| `title`, `agency`, `agencyCode`, `number` | Opportunity title, agency, code, opportunity number | Project title, institute, IC code, project number | Award title, division, directorate, award ID |
| `openDate` / `closeDate` | Posted date / application close date | Project start / end | Award start / expiration |
| `amount`, `amountType` | Award ceiling | Fiscal-year award (total cost) | Estimated total award |
| `amountFloor`, `totalProgramFunding`, `expectedAwards` | ✔ | | |
| `eligibility` | Applicant types + eligibility notes | | |
| `recipient`, `principalInvestigator` | | ✔ | ✔ |
| `summary` | Synopsis (up to 1,500 characters) | Abstract | Abstract |
| `fundingInstrument`, `fundingOpportunity`, `assistanceListing`, `fiscalYear` | ✔ | ✔ | ✔ |
| `status` | forecasted / posted / closed / archived | active / ended | active / ended |
| `url` | Grants.gov detail page | RePORTER project page | NSF award page |

#### Files in the key-value store

| Key | What it is |
|---|---|
| `GRANTS_XLSX` | Excel workbook: all results with clickable links, a **Search log** sheet and a **Read me** sheet |
| `GRANTS_CSV` | Same table as CSV (UTF-8, opens cleanly in Excel) |
| `SUMMARY` | JSON search log: your filters, per-source counts (found, filtered out, returned) and any source that was unavailable |

### For AI agents

Use this Actor to find open federal grant opportunities (Grants.gov) and funded NIH / NSF awards. Call it with Apify's MCP server (`https://mcp.apify.com`, tool `call-actor`, Actor `pandadad0214/grants-finder`) or the API (`POST https://api.apify.com/v2/acts/pandadad0214~grants-finder/run-sync-get-dataset-items`).

Minimal input:

```json
{"keywords": "artificial intelligence", "sources": ["grants_gov", "nih", "nsf"], "maxResultsPerSource": 10}
```

Each dataset item includes:

- `agentSummary`: one line, e.g. `Grants.gov opportunity (posted): Title; Agency; $500,000; closes/ends 2026-01-15; no. ...` (the existing `summary` field is the grant's own description)
- `source`, `recordType`, `status`: where it came from and whether it is open, forecasted, active or ended
- `title`, `agency`, `number`: what and who
- `openDate`, `closeDate`: ISO dates (YYYY-MM-DD)
- `amount`: USD
- `eligibility`, `summary`, `url`: details and link

The run's key-value store has a `SUMMARY` record with counts (`returned`, `bySource`) and file names (`GRANTS_XLSX`, `GRANTS_CSV`), a one-line `takeaway`, and `nextStep` (the suggested follow-on tool). Every input field has a description with formats, units and limits.

### Grants.gov scraper pricing and free results

**Apify paid-plan discounts:** Bronze members pay 10% less, Silver 20% less and Gold 30% less per result. Free-plan prices are shown below; the discount applies automatically.

**$0.003 per result** returned to the dataset (pay-per-event), plus a tiny Actor-start fee of $0.00005. Excel, CSV and the search log are included. Runs that find nothing cost nothing beyond the start fee. Your **maximum charge per run** is respected: if it's lower than the number of results, the results are shared evenly across sources.

### FAQ

**Is there a free way to try this Grants.gov scraper?** Yes. Apify's free plan includes $5 of monthly platform credit, enough for roughly 1,666 grants at $0.003 each.

**Is this data official?** Yes. Every row comes from the public APIs of Grants.gov, NIH RePORTER and the NSF Award Search. Grants Finder is not affiliated with or endorsed by any US government agency.

**Why do NIH and NSF show awards instead of open calls?** Those APIs publish funded projects. NIH and NSF open calls are also listed on Grants.gov, so the Grants.gov source covers them. Award data shows who gets funded, typical amounts and which programs fund your topic.

**Why are some amounts empty?** Some Grants.gov opportunities don't publish an award ceiling. If you set an amount filter, those rows are left out and counted in `SUMMARY`.

**How fresh is it?** Live: every run queries the APIs directly. Schedule the Actor (for example weekly) to watch for new opportunities.

**Can I use it from code or an AI agent?** Yes, via the Apify API, the Python/JS clients, or as a tool through Apify's MCP server.

### More Panda Federation tools

- [Reference Checker](https://apify.com/pandadad0214/reference-checker)
- [Citation Generator](https://apify.com/pandadad0214/citation-formatter)
- [Google Scholar Scraper Alternative](https://apify.com/pandadad0214/literature-search)
- [PubMed Scraper](https://apify.com/pandadad0214/pubmed-evidence-table)
- [Academic Research MCP Server](https://apify.com/pandadad0214/panda-research-mcp)
- [Researcher & Expert Finder](https://apify.com/pandadad0214/researcher-expert-finder)

[All Panda Federation Actors on Apify](https://apify.com/pandadad0214)

Questions or a custom data feed? Open an issue on this Actor's **Issues** tab.

### Changelog

- **2026-10-30 (hint update):** Next-step hint now points to Researcher & Expert Finder.
- **2026-10-30 (agent update):** Built for AI agents: a one-line `agentSummary` on every result, `takeaway` and `nextStep` in the SUMMARY record, and input fields with formats, limits and examples.
- **2026-10-30:** New search-friendly title and page, FAQ, safe demo run on empty input, Bronze/Silver/Gold discounts, output screenshot, and a next-step hint in the log and `NEXT_STEP` record pointing to Literature Search.
- **2026-10-29:** First public release with pay-per-event pricing.

# Actor input Schema

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

What the funding is for, e.g. artificial intelligence, rural broadband, opioid prevention. Use quotes for exact phrases ("machine learning"). NIH also understands AND / OR / NOT.

## `sources` (type: `array`):

Grants.gov = open and upcoming funding opportunities you can apply to. NIH RePORTER and NSF = awards already made (who got funded, how much, by which program).

## `maxResultsPerSource` (type: `integer`):

You pay per returned result, so this also caps the cost. Up to 1,000 per source. Whole number, 1 to 1,000 results per source; default 50.

## `agencies` (type: `array`):

Optional. Grants.gov agency codes or names (HHS-NIH11, NSF, DOE, USDA, ED, Geological Survey; a code prefix like HHS matches all HHS sub-agencies). NIH institutes (NCI, NIAID, NIMH… or NIH for all). NSF directorates (CSE, BIO, GEO, MPS, SBE, EDU, ENG, TIP, or NSF for all). A source is skipped when none of its agencies are listed.

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

Optional. 2025, 2025-06 or 2025-06-30. Applies to the Grants.gov posted date, the NIH project start date and the NSF award date.

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

Optional. 2026, 2026-12 or 2026-12-31.

## `minAmount` (type: `integer`):

Optional. Grants.gov award ceiling, NIH fiscal-year award or NSF estimated total. When set, rows whose source publishes no amount are left out (and counted in the summary). Whole number, 0 or more USD.

## `maxAmount` (type: `integer`):

Optional. Whole number, 0 or more USD.

## `grantsGovStatuses` (type: `array`):

Default: forecasted and posted (still open or coming soon).

## `grantsGovFundingCategories` (type: `array`):

Optional Grants.gov category codes, e.g. ST (science and technology), HL (health), ED (education), AG (agriculture), ENV (environment), CD (community development).

## `nihFiscalYears` (type: `array`):

Optional, e.g. 2025, 2026. Each NIH project appears once (its latest matching year).

## `nihActiveOnly` (type: `boolean`):

Only return NIH projects that are currently active. Default: off.

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

Relevance (default) or newest first (by posted / start date).

## `includeGrantsGovDetails` (type: `boolean`):

Fetch each opportunity's detail page for award ceiling, eligibility and summary. Turn off for a faster title-and-deadline list. Default: on.

## Actor input object example

```json
{
  "keywords": "artificial intelligence",
  "sources": [
    "grants_gov",
    "nih",
    "nsf"
  ],
  "maxResultsPerSource": 50,
  "agencies": [
    "HHS-NIH11",
    "NSF"
  ],
  "dateFrom": "2025-01",
  "dateTo": "2026-12-31",
  "minAmount": 50000,
  "maxAmount": 500000,
  "grantsGovStatuses": [
    "forecasted",
    "posted"
  ],
  "grantsGovFundingCategories": [
    "HL",
    "ST"
  ],
  "nihFiscalYears": [
    "2025",
    "2026"
  ],
  "nihActiveOnly": false,
  "sortBy": "relevance",
  "includeGrantsGovDetails": true
}
```

# Actor output Schema

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

No description

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

No description

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

No description

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

Run-level summary record. Agent-friendly keys: `takeaway` (one-line plain-English result of the run), `nextStep` and `nextSteps` (the suggested follow-on tool and its Store URL).

# 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 = {
    "keywords": "artificial intelligence"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pandadad0214/grants-finder").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 = { "keywords": "artificial intelligence" }

# Run the Actor and wait for it to finish
run = client.actor("pandadad0214/grants-finder").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 '{
  "keywords": "artificial intelligence"
}' |
apify call pandadad0214/grants-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pandadad0214/grants-finder"
        }
    }
}
```

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/Iza1SVsMkdaA2hMFL/builds/LoxnrJDhrSBHX9s11/openapi.json