# NSF Awards + SBIR Grants Scraper: Awardees, PIs, Amounts (`transparent_meteorite/nsf-sbir-awards`) Actor

Search National Science Foundation awards, including NSF SBIR and STTR small business grants: award ID, title, awardee, principal investigator and email, amount, dates, program and abstract. Free public NSF Awards API, no login, no proxy.

- **URL**: https://apify.com/transparent_meteorite/nsf-sbir-awards.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 award rows

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

## NSF Awards + SBIR Grants Scraper: Awardees, PIs, Amounts

**NSF awards** and **SBIR grants** from the public NSF Awards API: one row per award with awardee, principal investigator and email, amount, dates, program, directorate and abstract. Filter by SBIR or STTR small business grants, keyword, state or amount. No login, no proxy.

Find newly funded teams. This Actor lists National Science Foundation awards, with a one-click filter for NSF SBIR and STTR small business innovation grants, so grant offices, equipment vendors, university partners and deep-tech investors can see who just got funded and how to reach the principal investigator.

### What is NSF Awards + SBIR Grants Scraper?

It reads the free NSF Awards API (`api.nsf.gov`), the data behind the NSF award search site, and returns clean rows: award number, title, awardee organization, city and state, principal investigator, the PI work email NSF publishes, co-investigators, award amount, dates, program, directorate, division, award type, program officer and an abstract snippet. Run it from the Apify Console, the API, a schedule, n8n, Make or an AI agent, and export JSON, CSV, Excel or HTML.

### Why use it

- **Official source.** Data comes straight from the NSF Awards API, with a link to each award page.
- **SBIR and STTR in one switch.** The program filter finds small business grants; SBIR/STTR awards are a strong lead list for startups.
- **Contact-ready.** The PI name and work email NSF publishes with the award, plus co-PIs.
- **Several filters.** Keyword, state, awardee name, PI last name, minimum amount and date window.
- **Pay for rows only.** Filter first, then pay for the rows you receive. No monthly fee.

### Output

One row per award:

| Field | Meaning |
|---|---|
| `awardId`, `awardUrl` | NSF award number and its official award page. |
| `title` | Award title. |
| `awardee`, `awardeeCity`, `state` | The organization that received the award and where it is. |
| `pi`, `piEmail` | Principal investigator name and the work email NSF publishes (empty when none is listed). |
| `coPis` | Co-investigators as objects with `name` and `email`. |
| `amount` | Estimated total award amount in US dollars. |
| `fundsObligatedUsd` | Funds obligated to date in US dollars. |
| `awardDate`, `startDate`, `endDate` | Key dates as `YYYY-MM-DD`. |
| `agency` | Funding agency (NSF). |
| `directorate`, `division` | NSF directorate and division abbreviations, for example ENG and CBET. |
| `program`, `programType` | NSF funding program name, and SBIR, STTR or empty. |
| `awardType` | Transaction type, for example Standard Grant. |
| `programOfficer` | NSF program officer name. |
| `uei` | Unique Entity ID of the awardee. |
| `abstractSnippet` | First 500 characters of the public abstract. |
| `scrapedAt` | When the run read the data. |

### Sample output

```json
{
  "awardId": "2611922",
  "title": "SBIR Phase I: Lightweight flexible solar panels for space",
  "awardee": "Example Solar Inc",
  "state": "MI",
  "pi": "Jane Example",
  "piEmail": "jane@example.com",
  "amount": 305000,
  "awardDate": "2026-08-18",
  "startDate": "2026-09-01",
  "program": "SBIR Phase I",
  "programType": "SBIR",
  "agency": "NSF",
  "awardUrl": "https://www.nsf.gov/awardsearch/showAward?AWD_ID=2611922"
}
```

### Input

| Field | What it does |
|---|---|
| `programType` | `sbir_sttr` (default), `sbir`, `sttr` or `all` NSF awards. |
| `sinceDays` | Only awards dated in the last N days. Default 365, use 0 for all time. |
| `searchText` | Words in the title or abstract, for example `battery`. |
| `states` | Two-letter state codes of the awardee, for example `MI`, `CA`. Empty means all. |
| `awardeeName` | Part of the organization name. |
| `piLastName` | Principal investigator last name. |
| `minAmount` | Minimum estimated total amount in USD. |
| `maxItems` | Stop after this many rows. Default 100. |

Sample input:

```json
{
  "programType": "sbir_sttr",
  "searchText": "battery",
  "states": ["MI", "OH"],
  "sinceDays": 365,
  "maxItems": 100
}
```

### Pricing

Pay per event, no subscription. Current prices:

| Event | Price |
|---|---|
| Actor Start | $0.00005 |
| Award row | $0.0009 |

Apify's free plan includes monthly platform credit that covers test runs.

Examples at the current price (one `award-result` event per result; Free-plan tier):

| You pull | You pay |
|---|---|
| 100 results | $0.09 |
| 1,000 results | $0.90 |
| 10,000 results | $9.00 |

Scheduled runs stay cheap when each run only returns new records.

### What does this Actor do?

It queries the public NSF Awards API with your filters, 25 awards per request, and writes one row per award. The SBIR and STTR switch asks the API for the SBIR and STTR funding programs; duplicates are removed. No login, no proxy and no browser are used.

**Run in 30 seconds**

1. Open the Actor and press **Try for free** (a free Apify account is enough).
2. Keep the defaults (SBIR and STTR awards from the last year) and press **Start**.
3. Open the **Output** tab. Use the table view or download CSV, Excel or JSON.

### Use cases

- Build a weekly list of newly funded SBIR and STTR startups in your state or sector and send it to a CRM or an n8n workflow.
- Lab-equipment, materials and software vendors: find funded teams working on a topic such as battery, photonics or biosensors.
- University grant offices and tech-transfer teams: benchmark which institutions win NSF awards in a field.
- Deep-tech investors and accelerators: spot early-stage teams right after a Phase I or Phase II award.
- Researchers and journalists: track NSF funding by topic, state, directorate or amount.

### Limits

- Covers NSF awards, which includes NSF's own SBIR and STTR grants. It does not include SBIR awards made by other agencies.
- The NSF API returns 25 rows per request, so very large pulls take a few minutes. Up to 5,000 rows per run.
- `piEmail` is only filled when NSF publishes one for the award; older awards often have none.
- Amounts are the estimated total reported by NSF, not a payment record.

### Related Actors

- [NIH Research Grants Awarded Tracker](https://apify.com/transparent_meteorite/nih-research-grants-awarded) lists NIH grants by year, state and institute.
- [Website Tech Stack](https://apify.com/transparent_meteorite/website-tech-stack) detects which technologies a website runs on.
- [Developer Signals](https://apify.com/transparent_meteorite/developer-signals) tracks public developer activity signals for companies.

Found a bug or need a field? Open an issue on the Issues tab with the run URL.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~nsf-sbir-awards/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"programType": "sbir_sttr", "sinceDays": 365, "maxItems": 30}'
```

The call waits up to 5 minutes. For bigger inputs, start the run with `/runs` instead and read the dataset when it finishes.

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/nsf-sbir-awards").call(run_input={"programType": "sbir_sttr", "sinceDays": 365, "maxItems": 30})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**MCP (AI agents):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/nsf-sbir-awards` to Claude, Cursor or any MCP client. Your agent can then find newly funded SBIR startups, list NSF awards by topic and look up principal investigators by calling this Actor, and it gets back the same flat rows described above.

| Tool | Setup |
|---|---|
| n8n | Add the Apify node, choose "Run Actor", set the actor to `transparent_meteorite/nsf-sbir-awards`, paste the input JSON, then add a "Get Dataset Items" step and map the fields to your sheet, CRM or Slack. |
| Make and Zapier | Use the Apify app's "Run Actor" action with this actor and the input JSON, then map the dataset items. |
| Clay | Add an HTTP API column that calls the run-sync endpoint above. |
| Schedules | In Apify Console, Schedules, run it daily or weekly with the same input for a steady feed. |

### Search terms people use

NSF awards search, NSF award API scraper, SBIR grants list, SBIR STTR winners, NSF SBIR Phase I Phase II awardees, NIH grants and NSF grants companion list, find startups that won SBIR grants, grant winner leads with PI email, federal research funding data export.

### FAQ

**Which awards are included?**
Every award the NSF Awards API returns for your filters. With the default program setting you get NSF SBIR and STTR small business awards from the last 365 days.

**Does it include SBIR grants from other agencies?**
No. It covers NSF awards only, which includes NSF's SBIR and STTR programs. Other agencies publish through different systems.

**Where does the PI email come from?**
NSF publishes the principal investigator work email on many award records. The Actor passes it through as published. Use it responsibly and follow CAN-SPAM, GDPR and your own privacy rules; honor opt-outs.

**Why is `piEmail` empty on some rows?**
NSF does not list an email for every award, especially older ones. The field is empty rather than guessed.

**Can I also get NIH grants?**
Yes, with our companion [NIH Research Grants Awarded Tracker](https://apify.com/transparent_meteorite/nih-research-grants-awarded), which covers organization-level NIH awards.

### More from DWA Open Data

Browse all our data Actors, with live prices and sample output, at [open-data-actors.pages.dev](https://open-data-actors.pages.dev).

***

**Feedback:** if this Actor was useful, or if it fell short, an honest review on the [Reviews tab](https://apify.com/transparent_meteorite/nsf-sbir-awards/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/nsf-sbir-awards/issues) and we usually reply within one business day.

# Changelog

This Actor's version history is a separate document: https://apify.com/transparent_meteorite/nsf-sbir-awards/changelog.md

# Actor input Schema

## `searchText` (type: `string`):

Words in the award title or abstract, for example battery, quantum sensing or wastewater. Leave empty for all topics.

## `programType` (type: `string`):

SBIR and STTR are NSF's small business innovation grants, a strong lead list for deep-tech startups. Choose All NSF awards for university research grants too.

## `sinceDays` (type: `integer`):

Only awards dated within this many days. Use 0 for all time.

## `states` (type: `array`):

Two-letter US state codes of the awardee, for example MI or CA. Leave empty for all states.

## `awardeeName` (type: `string`):

Part of the organization name, for example Michigan or Labs.

## `piLastName` (type: `string`):

Only awards whose principal investigator has this last name.

## `minAmount` (type: `integer`):

Only awards with an estimated total of at least this amount. 0 means no minimum.

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

Stop after this many rows. You pay only for rows delivered.

## Actor input object example

```json
{
  "programType": "sbir_sttr",
  "sinceDays": 365,
  "minAmount": 0,
  "maxItems": 50
}
```

# 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": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/nsf-sbir-awards").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": 50 }

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/nsf-sbir-awards").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 '{
  "maxItems": 50
}' |
apify call transparent_meteorite/nsf-sbir-awards --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/nsf-sbir-awards"
        }
    }
}
```

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/H1nnj5T7Q4uuWOyxN/builds/SosH5RiT3IrgbLK63/openapi.json
