# Grants.gov Funding Opportunities Scraper (`talcoe/grants-gov-opportunities`) Actor

Search open and forecasted federal grants by keyword, category and eligibility, with agency, deadline and award ceiling in every record. Pay only per result returned.

- **URL**: https://apify.com/talcoe/grants-gov-opportunities.md
- **Developed by:** [M Usama](https://apify.com/talcoe) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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.

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

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

It returns open and forecasted U.S. federal grant opportunities from Grants.gov: title, agency, status, posted date, due date, award ceiling, award floor, eligible applicant types and a plain text description. Grant writers, nonprofits, universities, small businesses and consultants use it to monitor new funding by keyword, category and eligibility without browsing Grants.gov by hand. Filters keep each run small, and you only pay for the results returned.

### Data source

Reads the public JSON API that grants.gov's own search page calls in the browser (`api.grants.gov/v1/api/search2` for listings, `fetchOpportunity` for details), so results are as fresh as the live site and require no login or key.

### Why use it?

- Monitor new grants in a category (health, education, environment, and so on) as they post.
- Build a lead list of open opportunities a specific applicant type (small business, nonprofit, tribal government, university) is eligible for.
- Track deadlines and award ceilings across many agencies in one feed instead of checking Grants.gov by hand.
- Feed a spreadsheet, CRM or Slack channel through a Schedule and an Integration instead of a manual weekly search.

### How to use it

1. Open the Actor and set the filters: keyword, opportunity status, funding category, eligibility, and how recently it was posted.
2. Click Start. Download results as JSON, CSV or Excel, or read them through the API.
3. Add a Schedule and an Integration (Slack, Google Sheets, webhook) to get new opportunities automatically.

### Input

| Field | Description |
|---|---|
| `keyword` | Search terms matched against the title and description. Blank returns all opportunities that match the other filters. |
| `oppStatuses` | Which statuses to include: posted, forecasted, closed, archived. Default is posted and forecasted. |
| `fundingCategory` | Limit to one funding activity category (Health, Education, Environment, and so on). Default is any category. |
| `eligibility` | Limit to opportunities open to one applicant type (small business, nonprofit, state government, and so on). Default is any applicant. |
| `postedInLastDays` | Only include opportunities posted within this many days. Default is no limit. |
| `maxResults` | Hard stop for the run. You are billed per result, so this caps the cost. |
| `proxyConfiguration` | Apify proxy is recommended for larger runs. |

Example input:

```json
{
    "keyword": "health",
    "oppStatuses": ["posted", "forecasted"],
    "fundingCategory": "",
    "eligibility": "",
    "postedInLastDays": "0",
    "maxResults": 60
}
```

### Output

Every record has the same shape:

```json
{
    "id": "grants:357658",
    "opportunityNumber": "PAR-25-155",
    "title": "Limited Competition: Small Grant Program for the NCATS Clinical and Translational Science Award (CTSA) Program (R03 Clinical Trial Optional)",
    "agency": "National Institutes of Health",
    "status": "posted",
    "postedDate": "2024-12-11T05:00:00.000Z",
    "dueDate": "2026-10-19T04:00:00.000Z",
    "awardCeiling": 50000,
    "awardFloor": null,
    "estimatedTotalFunding": null,
    "numberOfAwards": null,
    "eligibleApplicants": ["Small businesses", "State governments", "Nonprofits having a 501(c)(3) status with the IRS, other than institutions of higher education"],
    "fundingCategory": ["Health"],
    "fundingInstrument": ["Grant"],
    "costSharingRequired": false,
    "cfdaNumbers": ["93.350"],
    "description": "The purpose of this NOFO is to enhance the capability of NCATS CTSA Program KL2 scholars...",
    "url": "https://www.grants.gov/search-results-detail/357658",
    "announcementUrl": "http://grants.nih.gov/grants/guide/pa-files/PAR-25-155.html",
    "scrapedAt": "2026-09-24T08:47:12.513Z"
}
```

| Field | Meaning |
|---|---|
| `id` | Stable key (`grants:<opportunityId>`), safe for deduplication between runs |
| `opportunityNumber` | Grants.gov solicitation or NOFO number |
| `title` | Opportunity title |
| `agency` | Publishing agency name |
| `status` | posted, forecasted, closed or archived |
| `postedDate` | ISO date the opportunity was or will be posted |
| `dueDate` | ISO date applications are due |
| `awardCeiling` | Maximum award amount in USD, or null if not published |
| `awardFloor` | Minimum award amount in USD, or null if not published |
| `estimatedTotalFunding` | Total program funding, or null if not published (forecast opportunities only) |
| `numberOfAwards` | Expected number of awards, or null if not published |
| `eligibleApplicants` | Applicant types allowed to apply |
| `fundingCategory` | Funding activity categories |
| `fundingInstrument` | Grant, cooperative agreement or other instrument type |
| `costSharingRequired` | Whether cost sharing or matching funds are required |
| `cfdaNumbers` | Assistance Listing (CFDA) numbers |
| `description` | Plain text summary of the opportunity |
| `url` | Grants.gov opportunity detail page |
| `announcementUrl` | Link to the full agency announcement, if the agency publishes one |

### Pricing

Pay per event: a small fee when a run starts, then a fixed price per result returned. You only pay for records that pass your filters. Set `maxResults` to cap any run.

### Limitations

- Covers Grants.gov listings only, not agency specific systems that never publish to Grants.gov.
- Some opportunities do not publish an award ceiling, floor or estimated total funding; those fields are null rather than guessed.
- `eligibility` and `fundingCategory` filter by the codes Grants.gov itself uses, so unusual combinations may return zero results if the opportunity was not tagged with that exact code.

### FAQ

**Is this legal?** The Actor reads the same public JSON API the Grants.gov search page calls in any visitor's browser, with no login and no personal data. You are responsible for how you use the data.

**Something is missing or broken?** Open an issue in the Issues tab; response time is usually under a day.

# Actor input Schema

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

Search terms matched against the opportunity title and description. Leave blank to return all opportunities that match the other filters.

## `oppStatuses` (type: `array`):

Which opportunity statuses to include. Posted and forecasted are the open and upcoming ones.

## `fundingCategory` (type: `string`):

Limit results to one funding activity category. Leave on Any category to skip this filter.

## `eligibility` (type: `string`):

Only return opportunities open to this applicant type. Leave on Any applicant to skip this filter.

## `postedInLastDays` (type: `string`):

Only include opportunities posted within this many days. Use No limit for the widest result set.

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

Hard stop for the run. You are billed per result, so this caps the cost.

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

Apify proxy is recommended for larger runs.

## Actor input object example

```json
{
  "keyword": "health",
  "oppStatuses": [
    "posted",
    "forecasted"
  ],
  "fundingCategory": "",
  "eligibility": "",
  "postedInLastDays": "0",
  "maxResults": 60,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keyword": "health",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("talcoe/grants-gov-opportunities").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": "health",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("talcoe/grants-gov-opportunities").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": "health",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call talcoe/grants-gov-opportunities --silent --output-dataset

```

## MCP server setup

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

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/IhdkZrTdWtfvwcTAR/builds/zVzOicPdg2FVZ41BG/openapi.json