# Grant Opportunity Finder (`arched_friend/grant-opportunity-finder`) Actor

Find open and upcoming US federal grants on Grants.gov by keyword, agency or who can apply. Returns award size, total funding, deadline, eligibility and contact, soonest deadline first, and flags new grants and forecasts that just opened.

- **URL**: https://apify.com/arched\_friend/grant-opportunity-finder.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 grant returneds

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

## Grant Opportunity Finder: Every Open US Federal Grant, Soonest Deadline First

Find open and upcoming US federal grants on Grants.gov by keyword, agency or who is allowed to apply. You get the award size, the total program funding, the deadline and the days left, the eligibility rules and the program contact. On every run after the first, it flags new grants and forecasts that have just opened for applications.

Built for grant writers and development teams who still check Grants.gov by hand every week and hope they didn't miss one.

### How it works

```mermaid
flowchart LR
    A["Keywords, agencies,<br/>who can apply"] --> B["Grants.gov search"]
    B --> C["Full record per grant:<br/>award size, eligibility, contact"]
    C --> D["One row per grant,<br/>soonest deadline first"]
    D --> E{"Since last run?"}
    E -->|not seen| F["new-opportunity"]
    E -->|forecast opened| G["now-open"]
    E -->|deadline moved| H["deadline-changed"]
```

There's no scraping and no API key. It reads Grants.gov's own public API, the same one its website uses, so a restyled page won't break it.

### Built for

- **Nonprofit development teams** building a funding pipeline
- **Grant writers and consultants** watching for clients across many programs
- **Universities and research offices** tracking NSF, NIH, DOE and DOD calls
- **Small businesses** looking for SBIR and other for-profit-eligible funding
- **Cities, counties and tribes** that need every infrastructure and community grant

### Input

```json
{
  "keywords": ["broadband", "digital equity"],
  "eligibilities": ["12"],
  "minAwardCeiling": 250000,
  "closingWithinDays": 60,
  "onlyChanged": true
}
```

| Setting | What it does |
| --- | --- |
| `keywords` | What the grant is for. Each keyword runs its own search, most relevant first |
| `statuses` | `forecasted` (coming soon), `posted` (open now), or both |
| `eligibilities` | Only grants your organisation type can apply for |
| `fundingCategories` | Health, Education, Energy, Science and Technology and so on |
| `agencies` | Grants.gov agency codes such as `NSF` or `HHS-NIH11` |
| `minAwardCeiling` | Skip grants whose largest award is too small to be worth the effort |
| `closingWithinDays` | Only deadlines in the next N days |
| `onlyChanged` | Return nothing on a quiet run |
| `timeBudgetSecs` | How long a run may spend before returning what it has |

### Output

```json
{
  "opportunityNumber": "25-514",
  "title": "NSF Scholarships in Science, Technology, Engineering, and Mathematics Program",
  "agency": "U.S. National Science Foundation",
  "status": "posted",
  "closeDate": "2027-03-02",
  "daysUntilClose": 160,
  "awardCeiling": 5000000,
  "awardFloor": 1000000,
  "estimatedTotalFunding": 120000000,
  "expectedAwards": 60,
  "costSharing": false,
  "fundingInstruments": ["Grant"],
  "eligibleApplicants": ["Others (see text field entitled \"Additional Information on Eligibility\" for clarification)"],
  "contactEmail": "grantsgovsupport@nsf.gov",
  "moreInfoUrl": "http://www.nsf.gov/publications/pub_summ.jsp?ods_key=nsf25514",
  "url": "https://www.grants.gov/search-results-detail/357498",
  "matchedKeywords": ["rural"],
  "changeType": "new-opportunity",
  "checkedAt": "2026-09-23T18:08:55.059Z"
}
```

Rows come back **soonest open deadline first**, so a grant closing this week sits at the top instead of being buried by posting date.

**A forecast that opens is the most useful alert here.** Agencies announce many grants weeks or months early as forecasts. The day one moves to posted, it comes back as `now-open`, which is usually the day you want to start writing.

### Turn it into a weekly funding alert

```json
{
  "keywords": ["mental health", "substance use"],
  "eligibilities": ["12", "13"],
  "onlyChanged": true
}
```

Schedule it weekly. The first run records what's already out there without alerting you. After that, each run returns only new grants, grants that just opened and moved deadlines.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~grant-opportunity-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["climate resilience"],
    "statuses": ["posted"],
    "closingWithinDays": 45
  }'
```

### Pricing

You pay $0.002 for each grant returned. A quiet run with `onlyChanged` on costs nothing.

| Tracking federal grants weekly | Monthly cost |
| --- | --- |
| Checking Grants.gov by hand | a few hours every week |
| Grant database subscriptions | roughly $100 to $300 per month |
| This Actor | under $1 per month for most searches |

### Common questions

**Why are some award amounts null?** The agency left them blank. Grants.gov stores a blank amount as 0, and a $0 ceiling isn't a real ceiling, so it's returned as null. The `minAwardCeiling` filter keeps those grants rather than hiding real money.

**Why did a keyword find a grant that doesn't mention it in the title?** Grants.gov matches any of the words anywhere in the listing, and orders results by relevance. A single precise word (`broadband`) usually beats a long phrase. Use `excludeTerms` to trim the rest.

**Does it cover foundation or state grants?** No. It covers federal grants, which is everything listed on Grants.gov.

**Do I need an API key?** No. The Grants.gov API is public and keyless.

### Related products

- **Federal Contract Finder** to see who already won federal money in your field
- **Regulation Change Monitor** for the Federal Register notices behind new programs
- **Clinical Trial Monitor** and **FDA Recall Monitor** for health research teams
- **EU Tender Monitor** and **UK Tender Monitor** for public money outside the US

# Actor input Schema

## `keywords` (type: `array`):

What the grant is for, one per line, for example broadband or opioid prevention. Grants.gov matches any of the words, most relevant first, so a single precise word often beats a phrase. Each keyword runs its own search and the results are merged.

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

Forecasted grants are announced but not open yet; posted grants are taking applications now.

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

Only grants open to these applicant types. Leave empty for all.

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

Only grants in these categories. Leave empty for all.

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

Optional. Grants.gov agency codes, one per line, for example NSF, HHS-NIH11 or DOE. A top-level code such as DOD includes its sub-agencies.

## `minAwardCeiling` (type: `integer`):

Drop grants whose largest single award is below this. Grants that state no ceiling are kept, since many agencies leave it blank.

## `closingWithinDays` (type: `integer`):

Only grants whose deadline falls in the next N days. 0 keeps everything, including grants with no stated deadline.

## `excludeTerms` (type: `array`):

Drop grants whose title, agency or description contains any of these, one per line.

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

Reads each grant's full record for award ceiling, total funding, eligibility, description and contact. Turn off for a faster list of titles and deadlines only.

## `onlyChanged` (type: `boolean`):

Return nothing on a quiet run. Turn this on for a scheduled search so you only hear about new grants, forecasts that just opened and moved deadlines.

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

The most grants to read for each keyword, newest first.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for one answer from Grants.gov before giving up on it.

## `timeBudgetSecs` (type: `integer`):

How long the run may spend before it returns what it has. Keeps a scheduled run predictable.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence"
  ],
  "statuses": [
    "forecasted",
    "posted"
  ],
  "eligibilities": [],
  "fundingCategories": [],
  "minAwardCeiling": 0,
  "closingWithinDays": 0,
  "includeDetails": true,
  "onlyChanged": false,
  "maxResults": 100,
  "requestTimeoutSecs": 30,
  "timeBudgetSecs": 150
}
```

# Actor output Schema

## `opportunities` (type: `string`):

One row per grant with award size, deadline, eligibility and contact, soonest deadline first, plus what changed since the last run.

## `runSummary` (type: `string`):

Counts of posted and forecasted grants, new ones, newly opened ones and total estimated funding.

# 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("arched_friend/grant-opportunity-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("arched_friend/grant-opportunity-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 arched_friend/grant-opportunity-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/grant-opportunity-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/jOwEWaQMUFvccr3ZF/builds/XwaeVDCGfUXHuUxSO/openapi.json