# Grants.gov Search Scraper (`brightpath-data/grants-gov-search`) Actor

Search current, forecasted and closed U.S. federal grant opportunities from Grants.gov and export clean, flat records.

- **URL**: https://apify.com/brightpath-data/grants-gov-search.md
- **Developed by:** [Nick Randall](https://apify.com/brightpath-data) (community)
- **Categories:** AI, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 grant opportunity 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

## Grants.gov Search Scraper

Search current, forecasted and closed U.S. federal grant opportunities and export clean, flat records.

Get structured grant opportunity data from Grants.gov as JSON, CSV or Excel, or call it as a tool from Claude, Cursor, ChatGPT or any MCP client. Built on the official Grants.gov Search2 API, so it does not break when the website changes. Pay only for the opportunities you receive.

### What you get

One record per grant opportunity with the fields people actually filter on: opportunity ID and number, title, awarding agency and agency code, open and close dates, status (posted, forecasted, closed, archived), document type, and the Assistance Listing Numbers (ALN, formerly CFDA numbers) tied to the opportunity. Turn on "Include full opportunity details" to add the description, award ceiling and floor, expected number of awards, estimated total funding, cost sharing requirement, eligible applicant types and funding instrument.

Every result is a flat record with stable field names, so it drops straight into a spreadsheet, a database or an AI agent's context.

### Why use this instead of the website

- Combine keyword, status, agency, funding category, eligibility and ALN filters in one call
- Pagination handled for you, with automatic retries and polite rate limiting
- Results in JSON, CSV, Excel or via API, or piped into Zapier, Make, n8n and Google Sheets
- Works as an MCP tool, so AI agents can look up open grants on demand
- No browser, no proxies, no personal data: fast runs and a tiny cost per result
- Monitoring made easy: schedule the Actor daily with a keyword to catch newly posted opportunities

### Input

| Field | Type | Default | Meaning |
|-------|------|---------|---------|
| `keyword` | string | | Free-text keywords searched across opportunity titles and descriptions |
| `statuses` | array | posted, forecasted | Any of posted, forecasted, closed, archived |
| `agencyCodes` | array | all | Grants.gov agency codes, e.g. "USAID" or "DOC-NOAA" |
| `fundingCategories` | array | all | Funding category codes, e.g. "ENV" or "HL" |
| `eligibilities` | array | all | Applicant eligibility codes, e.g. "99" or "25" |
| `aln` | string | | A single Assistance Listing Number (formerly CFDA), e.g. "93.859" |
| `sortBy` | string | open date, newest first | Open date, close date, agency or title, ascending or descending |
| `includeDetails` | boolean | false | Fetch the full synopsis for each result (one extra request per result) |
| `maxResults` | integer | 100 | Cap on opportunities saved. You are charged per opportunity, so this caps your cost. |

Example input:

```json
{
  "keyword": "renewable energy",
  "statuses": ["posted", "forecasted"],
  "maxResults": 200
}
```

### Output

Example result (shortened, with `includeDetails: true`):

```json
{
  "id": "356420",
  "number": "DE-FOA-0003201",
  "title": "Rural and Municipal Renewable Energy Pilot Program",
  "url": "https://grants.gov/search-results-detail/356420",
  "agencyCode": "DOE",
  "agency": "Department of Energy",
  "openDate": "08/01/2026",
  "closeDate": "10/15/2026",
  "oppStatus": "posted",
  "docType": "synopsis",
  "alnList": ["81.087"],
  "description": "This funding opportunity supports pilot-scale renewable energy projects in rural communities...",
  "awardCeiling": 2000000,
  "awardFloor": 250000,
  "expectedNumberOfAwards": 12,
  "estimatedFunding": 18000000,
  "costSharing": true,
  "applicantTypes": ["State governments", "City or township governments", "Nonprofits"],
  "fundingInstrument": ["Grant"]
}
```

Field reference: `id`, `number`, `title`, `url`, `agencyCode`, `agency`, `openDate`, `closeDate`, `oppStatus`, `docType`, `alnList[]`. With `includeDetails: true`, also: `description`, `awardCeiling`, `awardFloor`, `expectedNumberOfAwards`, `estimatedFunding`, `costSharing`, `applicantTypes[]`, `fundingInstrument[]`.

### Pricing

Pay per event. You are charged **$1.50 per 1,000 opportunities** saved to the dataset, plus a fraction of a cent per run start. Nothing is charged for results you do not receive. Set "Max total charge per run" in the run options to cap spending on any run. When a run reaches your cap it stops cleanly and keeps everything it already saved.

Rough guide: 1,000 opportunities cost $1.50 and take about 20 seconds (longer with "Include full opportunity details" turned on, since that adds one request per result).

### Use it from an AI agent (MCP)

This Actor is available as an MCP tool through the Apify MCP server. Add it to your client, then ask the agent for the data in plain language.

Claude Desktop, Claude Code or Cursor (`mcp.json` / `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=brightpath-data/grants-gov-search",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

ChatGPT and other clients that support remote MCP servers: add `https://mcp.apify.com/?actors=brightpath-data/grants-gov-search` as a connector with your Apify token.

Example prompt once connected: "Find posted grant opportunities about renewable energy from the Department of Energy and list the title, close date and estimated funding for each."

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/brightpath-data~grants-gov-search/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"renewable energy","statuses":["posted","forecasted"],"maxResults":100}'
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("brightpath-data/grants-gov-search").call(run_input={"keyword": "renewable energy", "statuses": ["posted", "forecasted"], "maxResults": 100})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Limits and fair use

- Up to 5,000 opportunities per run. For larger exports, split by status, agency or funding category.
- Requests are paced to be polite to the source; runs with "Include full opportunity details" on take roughly twice as long since each result needs a second request.
- Agency, funding category and eligibility codes must match the codes Grants.gov itself uses; see the code lists on grants.gov if a filter returns nothing.
- Opportunity contact names and emails are intentionally not collected.

### Data source and legal

Data comes from Grants.gov, the U.S. government's central listing of federal grant opportunities, through its official public Search2 API, which requires no login or key. The data is U.S. government public domain data. This Actor collects public, non-personal data only and does not bypass logins, paywalls or access controls. You are responsible for how you use the data.

### Support

Found a problem or need a field added? Open an issue on the Actor's Issues tab. Fixes for broken runs are prioritized.

# Actor input Schema

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

Free-text keywords searched across opportunity titles and descriptions, e.g. "renewable energy" or "rural broadband".

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

Which opportunity statuses to include. Defaults to posted and forecasted (open and upcoming opportunities).

## `agencyCodes` (type: `array`):

Limit to specific awarding agencies by their Grants.gov agency code, e.g. "USAID" or "DOC-NOAA".

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

Limit to specific funding category codes, e.g. "ENV" (environment) or "HL" (health). See the Grants.gov category list for codes.

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

Limit to specific applicant eligibility codes, e.g. "99" (unrestricted) or "25" (others). See the Grants.gov eligibility list for codes.

## `aln` (type: `string`):

Limit to a single Assistance Listing Number (formerly CFDA number), e.g. "93.859".

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

Order of results.

## `includeDetails` (type: `boolean`):

For each result, fetch the full synopsis: description, award ceiling/floor, expected number of awards, estimated total funding, cost sharing requirement, applicant types and funding instrument. This makes one extra request per result and slows the run down.

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

Maximum number of opportunities to save. You are charged per opportunity saved, so this also caps the cost of a run.

## Actor input object example

```json
{
  "keyword": "renewable energy",
  "statuses": [
    "posted",
    "forecasted"
  ],
  "sortBy": "openDate|desc",
  "includeDetails": false,
  "maxResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

The dataset with one flat record per result. Append ?format=csv or ?format=xlsx to the URL for other formats.

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

OUTPUT record in the key-value store: counts of results pushed and charged, requests, retries and duration.

# 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": "renewable energy",
    "statuses": [
        "posted",
        "forecasted"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("brightpath-data/grants-gov-search").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": "renewable energy",
    "statuses": [
        "posted",
        "forecasted",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("brightpath-data/grants-gov-search").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": "renewable energy",
  "statuses": [
    "posted",
    "forecasted"
  ]
}' |
apify call brightpath-data/grants-gov-search --silent --output-dataset

```

## MCP server setup

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

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/TdbH4DyID8pjaxtv5/builds/KK8O6UckbekNW5mVf/openapi.json