# NSF Research Grants Scraper (`parseforge/nsf-awards-scraper`) Actor

Scrape NSF research grant awards with 62 fields per record. Get award titles, abstracts, funding amounts, PI contact info, institution details, program info, and dates. Filter by keyword, agency, state, program, and date range.

- **URL**: https://apify.com/parseforge/nsf-awards-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🔬 NSF Research Grants Scraper

> 🚀 Scrape National Science Foundation awards with titles, funding amounts, abstracts, PI contacts, institutions, and program details. Filter by keyword, state, program, and date range.

> 🕒 Last updated: 2026-04-17

The National Science Foundation funds billions of dollars in research every year across science, engineering, and education. This Actor queries the NSF awards database and returns structured records with award IDs, titles, full abstracts, funding amounts, principal investigator names and emails, institution details, program names, and dates. You can filter by keyword, state, program name, and date range.

Universities tracking funding opportunities, researchers scouting who else is working in their field, policy analysts studying federal science spending, and grant writers looking for successful proposals all use this tool. Instead of clicking through individual award pages, you get a clean dataset in seconds.

| Target | National Science Foundation Awards Database |
|--------|-------------------------------|
| Use Cases | Grant monitoring, research landscape analysis, federal spending tracking, collaboration discovery |

---

### 📋 What it does

- 🎓 **Award metadata.** Titles, IDs, full abstracts, and transaction types for every NSF-funded grant.
- 💰 **Funding amounts.** Estimated totals and obligated funds for each award.
- 👨‍🔬 **PI information.** Principal investigator names, email addresses, and institutional affiliations.
- 🏛️ **Institution details.** Awardee names, addresses, cities, states, and ZIP codes.
- 🔍 **Flexible filtering.** Search by keyword, state code, NSF program name, and start date range.

Each record includes 60+ fields covering the award details, PI information, institution data, funding amounts, performance location, program details, directorate codes, and dates.

> 💡 **Why it matters:** Manually searching the NSF website and copying award data into spreadsheets takes hours for even a few dozen grants. This Actor collects thousands of records with full abstracts and PI contacts in a single run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>keyword</td><td>string</td><td>"artificial intelligence"</td><td>Search awards by topic. Examples: "machine learning", "climate change", "quantum computing".</td></tr>
<tr><td>awardeeState</td><td>string</td><td>-</td><td>Filter by 2-letter state code (e.g., CA, NY, TX).</td></tr>
<tr><td>fundProgram</td><td>string</td><td>-</td><td>Filter by NSF program name.</td></tr>
<tr><td>startDateStart</td><td>string</td><td>-</td><td>Awards starting after this date (MM/DD/YYYY format).</td></tr>
<tr><td>startDateEnd</td><td>string</td><td>-</td><td>Awards starting before this date (MM/DD/YYYY format).</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Maximum awards to return. Free users limited to 10. Paid users up to 1,000,000.</td></tr>
</tbody>
</table>

**Example: AI-related grants in California from 2024.**

```json
{
    "keyword": "artificial intelligence",
    "awardeeState": "CA",
    "startDateStart": "01/01/2024",
    "startDateEnd": "12/31/2024",
    "maxItems": 100
}
````

**Example: All quantum computing grants.**

```json
{
    "keyword": "quantum computing",
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** The NSF awards API is public and does not require authentication. Dates must use MM/DD/YYYY format. The scraper processes about 25 awards per second.

***

### 📊 Output

Each record contains **60+ fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 id | string | `"2401234"` |
| 📋 title | string | `"CAREER: Trustworthy Machine Learning for Healthcare"` |
| 📝 abstractText | string | `"This project investigates novel approaches..."` |
| 🏛️ awardeeName | string | `"University of California-Berkeley"` |
| 📍 awardeeCity | string | `"BERKELEY"` |
| 🗺️ awardeeStateCode | string | `"CA"` |
| 💰 estimatedTotalAmt | string | `"550000"` |
| 💵 fundsObligatedAmt | string | `"110000"` |
| 👨‍🔬 pdPIName | string | `"Jane Smith"` |
| 📧 piEmail | string | `"jsmith@berkeley.edu"` |
| 📅 startDate | string | `"06/01/2024"` |
| 📅 expDate | string | `"05/31/2029"` |
| 🏷️ fundProgramName | string | `"Robust Intelligence"` |
| 🏢 primaryProgram | string | `"Robust Intelligence"` |
| 🕐 scrapedAt | string | `"2026-04-09T12:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🎓 AI research grant at UC Berkeley</strong></summary>

```json
{
    "id": "2401234",
    "title": "CAREER: Trustworthy Machine Learning for Healthcare Applications",
    "abstractText": "This project investigates novel approaches to building reliable and interpretable machine learning models for clinical decision support systems.",
    "agency": "NSF",
    "awardeeName": "University of California-Berkeley",
    "awardeeCity": "BERKELEY",
    "awardeeStateCode": "CA",
    "awardeeZipCode": "947101749",
    "estimatedTotalAmt": "550000",
    "fundsObligatedAmt": "110000",
    "startDate": "06/01/2024",
    "expDate": "05/31/2029",
    "pdPIName": "Jane Smith",
    "piEmail": "jsmith@berkeley.edu",
    "fundProgramName": "Robust Intelligence",
    "primaryProgram": "Robust Intelligence",
    "transType": "Grant",
    "scrapedAt": "2026-04-09T12:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔬 Climate science grant at MIT</strong></summary>

```json
{
    "id": "2356789",
    "title": "Collaborative Research: Atmospheric CO2 Flux Monitoring Using Advanced Sensor Networks",
    "abstractText": "This collaborative project deploys a network of low-cost CO2 sensors across urban environments to measure atmospheric carbon flux with unprecedented spatial resolution.",
    "agency": "NSF",
    "awardeeName": "Massachusetts Institute of Technology",
    "awardeeCity": "CAMBRIDGE",
    "awardeeStateCode": "MA",
    "awardeeZipCode": "021394301",
    "estimatedTotalAmt": "380000",
    "fundsObligatedAmt": "380000",
    "startDate": "09/01/2023",
    "expDate": "08/31/2026",
    "pdPIName": "Robert Chen",
    "piEmail": "rchen@mit.edu",
    "fundProgramName": "Atmospheric Chemistry",
    "primaryProgram": "Atmospheric Chemistry",
    "transType": "Grant",
    "scrapedAt": "2026-04-09T12:05:00.000Z"
}
```

</details>

<details>
<summary><strong>💻 Quantum computing grant at Stanford</strong></summary>

```json
{
    "id": "2489012",
    "title": "QuIC-TAQS: Topological Approaches to Quantum Error Correction",
    "abstractText": "This project explores topological codes for fault-tolerant quantum computing, aiming to reduce the physical qubit overhead required for practical quantum error correction.",
    "agency": "NSF",
    "awardeeName": "Stanford University",
    "awardeeCity": "STANFORD",
    "awardeeStateCode": "CA",
    "awardeeZipCode": "943052004",
    "estimatedTotalAmt": "750000",
    "fundsObligatedAmt": "375000",
    "startDate": "01/01/2025",
    "expDate": "12/31/2027",
    "pdPIName": "Maria Gonzalez",
    "piEmail": "mgonzalez@stanford.edu",
    "fundProgramName": "Quantum Computing",
    "primaryProgram": "Quantum Information Science",
    "transType": "Grant",
    "scrapedAt": "2026-04-09T12:10:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🔬 | **60+ fields per record.** Full award details including abstracts, PI contacts, and funding amounts. |
| 🔍 | **Flexible filtering.** Search by keyword, state, program, and date range. |
| 👨‍🔬 | **PI contact data.** Names and email addresses for principal investigators. |
| 💰 | **Funding details.** Both estimated totals and obligated amounts included. |
| ⚡ | **Fast collection.** About 25 awards per second. |
| 📅 | **Schedule-ready.** Set weekly runs to monitor new awards in your field. |
| 📊 | **Multiple exports.** Download as CSV, Excel, JSON, or XML. |

> The NSF awards over $9 billion annually across 2,000+ programs, funding research at more than 2,000 institutions in all 50 states.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ NSF Awards Scraper** *(this Actor)* | $5 free credit, then pay-per-use | All NSF awards | **Live per run** | ⚡ 2 min |
| Manual NSF search | Free | Limited by time | Manual checks | 🕐 Hours |
| NSF API integration | Free | Full access | Per request | 🔧 2-4 hours |
| Third-party research databases | $500+/mo | Multi-agency | Weekly | 📋 Onboarding |

Pick this Actor when you want structured NSF award data without building your own API integration or managing pagination and rate limits.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the NSF Research Grants Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a keyword, choose filters, and set your max items.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎓 University Research Offices

- Monitor new awards in your institution's focus areas
- Identify collaboration opportunities with funded PIs
- Track competitor institutions' funding portfolios
- Build grant application strategy based on funded topics

</td>
<td width="50%" valign="top">

#### 📊 Science Policy Analysis

- Study federal spending trends across programs and states
- Track funding distribution by institution and region
- Analyze which research topics receive the most funding
- Build time-series datasets of award volumes

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📝 Grant Writing

- Research successful awards to model proposals after
- Find funded projects in your field with full abstracts
- Identify active NSF programs accepting your research area
- Study funded award amounts to calibrate budget requests

</td>
<td width="50%" valign="top">

#### 🏢 Technology and Industry

- Discover university research with commercial potential
- Identify emerging technology areas by funding trends
- Find principal investigators for partnership outreach
- Monitor grants that may produce licensable IP

</td>
</tr>
</table>

***

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20NSF%20Research%20Grants%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20NSF%20Research%20Grants%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20NSF%20Research%20Grants%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20NSF%20Research%20Grants%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

### ❓ Frequently Asked Questions

<details>
<summary><b>💳 Do I need a paid Apify plan to run this actor?</b></summary>

No. You can start right now on the free Apify plan, which includes **$5 in free monthly credit**. That is enough to run this actor several times and explore the output before committing to anything. Paid plans unlock higher limits, more concurrent runs, and larger datasets. [Create a free Apify account here](https://console.apify.com/sign-up?fpr=vmoqkp) to get started.

</details>

<details>
<summary><b>🚨 What happens if my run fails or returns no results?</b></summary>

Failed runs are not charged. If the source site changes, proxies get rate-limited, or a specific input matches nothing, re-run the actor or open our [contact form](https://tally.so/r/BzdKgA) and we will investigate. You can also check the run log in the Apify console to see why the run stopped.

</details>

<details>
<summary><b>📏 How many items can I scrape per run?</b></summary>

Free users are limited to **10 items per run** so you can preview the output and confirm the actor works for your use case. Paid users can raise maxItems up to **1,000,000** per run. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) if you need full scale.

</details>

<details>
<summary><b>🕒 How fresh is the data?</b></summary>

Every run fetches live data at the moment of execution. There is no cache or delay: the records you get reflect what the source returned at that moment. Schedule the actor to maintain a rolling snapshot of the data you need.

</details>

<details>
<summary><b>🧑‍💻 Can I call this actor from my own code?</b></summary>

Yes. Apify exposes every actor as a REST endpoint and ships first-class SDKs for [Node.js](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python). You can start a run, read the dataset, and handle webhooks from your own app in a few lines. All you need is your Apify API token.

</details>

<details>
<summary><b>📤 How do I export the data?</b></summary>

Every Apify dataset can be downloaded in one click from the console as CSV, JSON, JSONL, Excel, HTML, XML, or RSS. You can also pull results programmatically via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, and other destinations through built-in integrations.

</details>

<details>
<summary><b>📅 Can I schedule the actor to run automatically?</b></summary>

Yes. Use the Apify scheduler to run the actor on any cadence, from hourly to monthly. Results are saved to your dataset and can be delivered to webhooks, email, Slack, cloud storage, or automation tools such as Zapier and Make.

***

</details>

### 🔌 Automating NSF Awards Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the apify-client NPM package.
- 🐍 **Python.** Use the apify-client PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Set a weekly run to catch new awards in your research area as they are announced.

### 🔌 Integrate with any app

NSF Awards Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🏛️ GSA eLibrary Scraper**](https://apify.com/parseforge/gsa-elibrary-scraper) - Collect government contract data from GSA
- [**✈️ FAA Aircraft Registry Scraper**](https://apify.com/parseforge/faa-aircraft-registry-scraper) - Extract aircraft registration records
- [**📄 Hugging Face Papers Scraper**](https://apify.com/parseforge/huggingface-papers-scraper) - Collect AI/ML research papers
- [**🤖 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - Scrape AI model metadata
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Collect press releases and news

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data scrapers and tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the National Science Foundation (NSF) or any government agency. All trademarks mentioned are the property of their respective owners. Only publicly available data is collected.

# Actor input Schema

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

Free users: Limited to 10 awards. Paid users: Optional, max 1,000,000

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

Search awards by keyword (e.g. 'machine learning', 'climate change', 'quantum computing').

## `awardeeState` (type: `string`):

Filter by state (2-letter code, e.g. CA, NY, TX).

## `fundProgram` (type: `string`):

Filter by NSF program name.

## `startDateStart` (type: `string`):

Filter awards starting after this date (MM/DD/YYYY).

## `startDateEnd` (type: `string`):

Filter awards starting before this date (MM/DD/YYYY).

## Actor input object example

```json
{
  "maxItems": 10,
  "keyword": "artificial intelligence"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "keyword": "artificial intelligence"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nsf-awards-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 = {
    "maxItems": 10,
    "keyword": "artificial intelligence",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nsf-awards-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "keyword": "artificial intelligence"
}' |
apify call parseforge/nsf-awards-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/nsf-awards-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NSF Research Grants Scraper",
        "description": "Scrape NSF research grant awards with 62 fields per record. Get award titles, abstracts, funding amounts, PI contact info, institution details, program info, and dates. Filter by keyword, agency, state, program, and date range.",
        "version": "1.0",
        "x-build-id": "AFHerdMlr1NdcGtbV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nsf-awards-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nsf-awards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~nsf-awards-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nsf-awards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~nsf-awards-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nsf-awards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 awards. Paid users: Optional, max 1,000,000"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search awards by keyword (e.g. 'machine learning', 'climate change', 'quantum computing')."
                    },
                    "awardeeState": {
                        "title": "Awardee State",
                        "type": "string",
                        "description": "Filter by state (2-letter code, e.g. CA, NY, TX)."
                    },
                    "fundProgram": {
                        "title": "Program Name",
                        "type": "string",
                        "description": "Filter by NSF program name."
                    },
                    "startDateStart": {
                        "title": "Start Date From",
                        "type": "string",
                        "description": "Filter awards starting after this date (MM/DD/YYYY)."
                    },
                    "startDateEnd": {
                        "title": "Start Date To",
                        "type": "string",
                        "description": "Filter awards starting before this date (MM/DD/YYYY)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
