# Grants.gov Opportunities Scraper (`automation-lab/grants-gov-funding-opportunities-scraper`) Actor

Search official Grants.gov opportunities and export eligibility, deadlines, synopsis, Assistance Listings, award details, and source links.

- **URL**: https://apify.com/automation-lab/grants-gov-funding-opportunities-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.45 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Grants.gov Opportunities Scraper

Search official **Grants.gov opportunities** and export normalized US federal funding records for recurring grant discovery, deadline monitoring, and data analysis.

The Actor uses anonymous public Grants.gov JSON endpoints.
It enriches every saved search hit with the full public synopsis, applicant eligibility, Assistance Listings, award amounts, contacts, and canonical source links.
No Grants.gov login, browser, or proxy is required.

### What does Grants.gov Opportunities Scraper do?

The Actor turns Grants.gov search results into stable dataset rows.

It can:

- search by keyword;
- filter by forecasted, posted, closed, or archived status;
- restrict results to agency codes such as `NSF`;
- filter by Assistance Listing numbers (formerly CFDA);
- use eligibility, funding instrument, and funding category codes;
- keep only opportunities inside a close-date window;
- enrich list results with the official opportunity detail response;
- stop at a user-controlled result limit;
- produce source-linked records ready for schedules and integrations.

The Actor does not submit grant applications or rank applicant suitability.
It provides public source data for your own research and monitoring process.

### Who is this federal funding scraper for?

**Grant consultants** can build a repeatable feed of opportunities matching client sectors.

**Nonprofits and universities** can monitor agency programs and upcoming deadlines without manually copying Grants.gov pages.

**Small-business support teams** can collect relevant federal notices for internal review.

**Research administrators** can export Assistance Listings, eligibility, award limits, and contacts into a tracking system.

**Data teams** can load normalized grant records into a warehouse, spreadsheet, CRM, or alerting pipeline.

### Why use this Actor?

Grants.gov search cards contain only part of the information needed to evaluate an opportunity.
This Actor combines search and detail data in one run.

Useful differences include:

- official API data rather than brittle page selectors;
- a stable `opportunityId` for change detection;
- plain-text synopsis and eligibility fields;
- structured award floor, ceiling, expected awards, and estimated funding;
- both canonical human-readable and API source links;
- deterministic item limits and deadline filters;
- one default dataset that works with standard Apify integrations.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `opportunityId` | Stable Grants.gov identifier |
| `opportunityNumber` | Agency funding notice number |
| `title` | Public opportunity title |
| `agencyCode`, `agencyName` | Publishing federal agency |
| `status` | Forecasted, posted, closed, or archived state |
| `opportunityCategory` | Opportunity category from Grants.gov |
| `assistanceListings` | Assistance Listing numbers and program titles |
| `eligibility` | Structured applicant type codes and labels |
| `eligibilityDescription` | Detailed applicant eligibility text |
| `fundingInstruments` | Grant or cooperative-agreement classifications |
| `fundingCategories` | Funding activity classifications |
| `openDate`, `closeDate`, `archiveDate` | Normalized source dates |
| `synopsis` | Plain-text funding synopsis |
| `awardFloor`, `awardCeiling` | Published award range in US dollars |
| `estimatedFunding` | Estimated total program funding |
| `expectedAwards` | Published expected award count |
| `awardCriteria` | Cost-sharing and response-date details exposed by the source |
| `contactName`, `contactEmail`, `contactPhone` | Published agency contact details |
| `sourceUrl` | Canonical Grants.gov detail page |
| `lastUpdatedAt`, `scrapedAt` | Source update and collection dates |

Fields remain `null` when Grants.gov does not publish a value.
The Actor never fabricates missing award or deadline data.

### How to search Grants.gov opportunities

1. Open the Actor input page.
2. Enter a keyword such as `education` or `small business`.
3. Choose one or more statuses.
4. Add agency or Assistance Listing filters when needed.
5. Optionally enter a close-date range in `YYYY-MM-DD` format.
6. Set `maxItems` to control the maximum dataset size.
7. Click **Start**.
8. Open the default dataset or export it as JSON, CSV, Excel, XML, or RSS.

A useful first run is:

```json
{
  "keyword": "education",
  "statuses": ["posted"],
  "maxItems": 10
}
```

### Input parameters

#### `keyword`

Optional text search passed to the official Grants.gov search service.
Leave it empty to browse by structured filters.

#### `statuses`

One or more of `forecasted`, `posted`, `closed`, and `archived`.
The default is `forecasted` plus `posted`.

#### `agencies`

Optional Grants.gov agency codes.
For example, use `NSF` for the U.S. National Science Foundation.

#### `assistanceListings`

Optional Assistance Listing numbers, such as `47.076`.
These identifiers were formerly called CFDA numbers.

#### `eligibilities`

Optional Grants.gov applicant eligibility codes.
Use source codes, not free-text applicant descriptions.

#### `fundingInstruments`

Optional funding instrument codes such as `G` for Grant or `CA` for Cooperative Agreement.

#### `fundingCategories`

Optional Grants.gov funding activity category codes.

#### `closeDateFrom` and `closeDateTo`

Optional inclusive close-date bounds in `YYYY-MM-DD` format.
Records without a published close date do not match an active date bound.

#### `maxItems`

Maximum enriched records saved to the dataset.
The default is 25 and the supported range is 1–5,000.

### Output example

A current result has this shape:

```json
{
  "opportunityId": "334326",
  "opportunityNumber": "21-595",
  "title": "Tribal Colleges and Universities Program",
  "agencyCode": "NSF",
  "agencyName": "U.S. National Science Foundation",
  "status": "posted",
  "assistanceListings": [
    {
      "number": "47.076",
      "title": "Education and Human Resources"
    }
  ],
  "openDate": "2021-06-24",
  "closeDate": "2026-09-01",
  "awardFloor": 100000,
  "awardCeiling": 3500000,
  "estimatedFunding": 10799836,
  "expectedAwards": 55,
  "sourceUrl": "https://www.grants.gov/search-results-detail/334326"
}
```

The full row also includes synopsis, eligibility, funding classifications, award criteria, contacts, and timestamps.

### Monitoring new and changed opportunities

Create an Apify Schedule to run the same input daily or weekly.
Use `opportunityId` as the stable key in your destination.
Compare `status`, `closeDate`, `lastUpdatedAt`, award fields, or synopsis text with the previous snapshot.

The Actor emits the current matching snapshot.
It does not keep a cross-run change database or send alerts by itself.
Use an integration, webhook, or your own database to perform change detection and notifications.

Useful recurring workflows include:

1. Track posted NSF opportunities each morning.
2. Watch a set of Assistance Listings for new notices.
3. Export deadlines in the next quarter to a calendar process.
4. Feed enriched opportunities into an internal grant qualification workflow.

### How much does it cost to extract Grants.gov opportunities?

This Actor uses pay-per-event pricing.
A run has a one-time **Start** charge plus one **Item processed** charge for each saved opportunity.
Empty or filtered-out records do not incur the item event.

Current source configuration starts at $0.005 per run and the BRONZE item rate is $0.00408 per saved opportunity.
Higher Apify plans receive lower per-item rates shown on the Actor pricing tab.

Example BRONZE calculations:

- 10 opportunities: $0.005 start + $0.0408 items = **$0.0458**;
- 100 opportunities: $0.005 start + $0.408 items = **$0.413**;
- 1,000 opportunities: $0.005 start + $4.08 items = **$4.085**.

Platform compute is covered by the active Actor pricing model.
Always check the pricing tab for the rate attached to your account plan.

### Export and integration workflows

The default dataset works with Apify's standard export formats and integrations.

You can:

- download JSON, JSONL, CSV, Excel, XML, or RSS;
- send finished-run webhooks;
- connect datasets to Google Sheets;
- import records into Make or Zapier;
- consume the dataset through the Apify API;
- load snapshots into a data warehouse;
- pass records to an AI classification or summarization step.

For large recurring jobs, keep filters specific and select a practical `maxItems`.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~grants-gov-funding-opportunities-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"education","statuses":["posted"],"maxItems":10}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/grants-gov-funding-opportunities-scraper').call({
  keyword: 'education',
  statuses: ['posted'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/grants-gov-funding-opportunities-scraper").call(
    run_input={
        "keyword": "education",
        "statuses": ["posted"],
        "maxItems": 10,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/grants-gov-funding-opportunities-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this equivalent MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/grants-gov-funding-opportunities-scraper"
    }
  }
}
```

Example prompts:

- “Find 20 currently posted federal education funding opportunities and summarize the eligibility.”
- “Export current NSF opportunities with deadlines and Assistance Listings.”
- “Collect small-business grant notices closing before the end of 2027.”

AI-generated assessments should always link back to `sourceUrl` for verification.

### Data quality and limitations

Results reflect the public Grants.gov API at run time.
Agency publishers control the completeness and wording of every notice.

Important limitations:

- some opportunities have no single close date;
- award ranges and expected award counts may be absent;
- eligibility details can be long and may refer to attached documents;
- source records can be revised, closed, archived, or removed;
- Grants.gov may throttle or temporarily fail requests;
- keyword relevance follows the official search behavior;
- `maxItems` limits saved matches, not the source's total hit count;
- close-date filtering can require scanning more search hits than are saved.

Transient API failures are retried three times with backoff.
A persistent upstream failure ends the run with a non-zero status rather than returning fabricated data.

### Legality and responsible use

Grants.gov publishes these records for public funding discovery.
Use the data responsibly and verify material eligibility, deadline, and application requirements on the canonical Grants.gov page and attached notice documents.

This Actor is not affiliated with Grants.gov or any federal agency.
It does not provide legal, financial, or grant-writing advice.
Do not treat a dataset row as an award decision or guarantee of eligibility.

Contact fields are official program contacts.
Use them only for relevant questions and do not send unsolicited bulk messages.

### Troubleshooting

#### My run returns no records

Broaden the keyword, remove optional codes, expand the date range, or include another status.
A valid zero-result search completes successfully and creates no item charge.

#### A record has a null deadline or award amount

The publishing agency did not provide that field in the current public synopsis.
Open `sourceUrl` and review the linked notice documents.

#### The run fails with a Grants.gov API error

Check the run log and retry later if the official service is unavailable.
The Actor already retries transient responses, so repeated immediate runs are unlikely to help.

#### An agency filter returns unexpected results

Use the exact Grants.gov agency code rather than a display name.
Test a small run before scheduling a large export.

#### Why are HTML tags absent from synopsis text?

The Actor converts the public HTML synopsis and eligibility descriptions to plain text for easier export and comparison.

### FAQ

#### Does it require a Grants.gov API key?

No.
The implemented official endpoints are anonymously accessible.

#### Does it scrape grants for college or private scholarships?

It searches federal opportunities published on Grants.gov.
A keyword may find relevant federal education programs, but the Actor does not scrape private scholarship directories.

#### Can it search farm grants?

Yes, when those opportunities are published on Grants.gov.
Use a keyword such as `farm` and optionally add agency, status, or deadline filters.

#### Can I monitor changes?

Yes.
Schedule repeat runs and compare rows by `opportunityId` in your destination.
The Actor returns snapshots; it does not send built-in change alerts.

#### Can I submit applications with this Actor?

No.
Application submission remains on the official Grants.gov workflow.

#### How many records can one run save?

Between 1 and 5,000, controlled by `maxItems`.
Source availability and filters determine the actual count.

### Related Automation Lab actors

For federal award and compliance research, consider:

- [Federal Audit Clearinghouse Scraper](https://apify.com/automation-lab/federal-audit-clearinghouse-scraper) for public single-audit submissions and federal award details;
- [NSF Research Awards Scraper](https://apify.com/automation-lab/nsf-research-awards-scraper) for funded NSF research award records;
- [SAM.gov Government Contracts Scraper](https://apify.com/automation-lab/samgov-government-contracts-scraper) for federal procurement opportunities rather than grants.

Use this Actor for current Grants.gov funding opportunities and deadlines.
Use the related Actors when the buyer job is awarded-project analysis, audit research, or contract opportunity monitoring.

# Actor input Schema

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

Words to match in Grants.gov opportunity titles, numbers, agencies, and synopsis content.

## `statuses` (type: `array`):

Include forecast, currently posted, closed, or archived opportunities.

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

Optional Grants.gov agency codes, such as NSF or HHS-NIH11.

## `assistanceListings` (type: `array`):

Optional Assistance Listing (formerly CFDA) numbers, such as 47.076.

## `eligibilities` (type: `array`):

Optional Grants.gov applicant eligibility codes.

## `fundingInstruments` (type: `array`):

Optional instrument codes, for example G for Grant or CA for Cooperative Agreement.

## `fundingCategories` (type: `array`):

Optional Grants.gov funding activity category codes.

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

Keep opportunities closing on or after this date (YYYY-MM-DD).

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

Keep opportunities closing on or before this date (YYYY-MM-DD).

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

Maximum number of matching enriched opportunity records to save.

## Actor input object example

```json
{
  "keyword": "education",
  "statuses": [
    "posted"
  ],
  "agencies": [],
  "assistanceListings": [],
  "eligibilities": [],
  "fundingInstruments": [],
  "fundingCategories": [],
  "maxItems": 10
}
```

# Actor output Schema

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

Default dataset containing normalized Grants.gov opportunity records.

# 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": "education",
    "statuses": [
        "posted"
    ],
    "agencies": [],
    "assistanceListings": [],
    "eligibilities": [],
    "fundingInstruments": [],
    "fundingCategories": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/grants-gov-funding-opportunities-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": "education",
    "statuses": ["posted"],
    "agencies": [],
    "assistanceListings": [],
    "eligibilities": [],
    "fundingInstruments": [],
    "fundingCategories": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/grants-gov-funding-opportunities-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keyword": "education",
  "statuses": [
    "posted"
  ],
  "agencies": [],
  "assistanceListings": [],
  "eligibilities": [],
  "fundingInstruments": [],
  "fundingCategories": [],
  "maxItems": 10
}' |
apify call automation-lab/grants-gov-funding-opportunities-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/grants-gov-funding-opportunities-scraper"
        }
    }
}

```

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

## OpenAPI specification

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