# NSF Award Data by Company — US Research Funding Recipients (`foxlabs/nsf-awards-company-data`) Actor

Pull National Science Foundation awards for any organization. Returns award ID, title, obligated amount, estimated total, programme, start and expiry dates, awardee address and principal investigator.

- **URL**: https://apify.com/foxlabs/nsf-awards-company-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 award 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

## NSF Award Data by Company — US Research Funding Recipients 🔬

**foXLabs research-funding series:** [NIH grants](https://apify.com/foxlabs/nih-reporter-organization-data) · [Clinical trial sponsors](https://apify.com/foxlabs/clinical-trial-sponsor-data) · [Research organizations (ROR)](https://apify.com/foxlabs/ror-research-organization-data) · [US nonprofits](https://apify.com/foxlabs/us-nonprofit-data) · [US federal contracts](https://apify.com/foxlabs/usaspending-contract-award-data)

🎉 See **which companies and institutions win NSF money** — award title, amount, dates, principal investigator and the awardee's **phone number** — straight from the NSF Award Search API, no key and no login.
Built for research-sales teams, grant analysts, and anyone mapping who funds US science.

### 🔍 What is this Actor — and when should you use it?

The National Science Foundation publishes every award it makes. This Actor searches that record by **awardee organization** and returns one clean row per award: what was funded, for how much, over which period, who the principal investigator was, and where the organization sits.

Unusually for an open award source, NSF also publishes the awardee's phone number — measured at **98% fill** on the default run — so these rows carry a direct contact route, not just a name.

**Use it when you need:** every NSF award a company or university holds; a list of organizations funded in your field; the PI behind a grant; or an outreach list of research-active organizations with phone numbers.

**Use something else when:** you want biomedical funding — NIH is a separate agency with its own record, covered by [NIH Grant Data](https://apify.com/foxlabs/nih-reporter-organization-data). For federal *contracts* rather than research grants, use [US Federal Contract Awards](https://apify.com/foxlabs/usaspending-contract-award-data).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/nsf-awards-company-data`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered award row.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
Run the Apify actor foxlabs/nsf-awards-company-data with
{"queries":["Georgia Tech Research Corporation"],"maxResultsPerQuery":25}
and list the awards with amounts and principal investigators.
```

### 📋 Overview

| | |
|---|---|
| **Source** | NSF Award Search API (National Science Foundation) |
| **Coverage** | NSF awards to companies, universities and research institutions |
| **Auth needed** | None. No API key, no login, no proxy required |
| **Row** | One NSF award |
| **Measured run** | 51 rows in 4.2 s for 3 organizations (2026-09-20, build 0.1.10) |
| **Pricing** | $0.003 per delivered row — $3 per 1,000 |

### ✨ Features

- 🏢 **Organization-first search** — type the awardee name, get their awards
- ☎️ **Phone number on 98% of rows** — the only direct contact detail NSF exposes
- 👤 **Principal investigator** named on the award
- 💵 **Obligated amount and estimated total** per award
- 📅 **Award date and full period of performance**
- 🟢 **Active flag** — tells you whether the award is still running
- ⚡ **Key-free and fast** — 51 rows in about 4 seconds, no proxy

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~nsf-awards-company-data/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Intel Corporation","SRI International"],"maxResultsPerQuery":25}'
```

### 🚀 Getting Started (3 steps)

1. **Name the organizations.** Put awardee names into `queries`. The default run searches `Intel Corporation`, `Georgia Tech Research Corporation` and `SRI International`.
2. **Set the depth.** `maxResultsPerQuery` caps how many awards come back per organization (default 25).
3. **Run it.** Rows arrive in the dataset; export to CSV/JSON/Excel or read them over the API.

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["Intel Corporation","Georgia Tech Research Corporation","SRI International"]` | Awardee organization names |
| `maxResultsPerQuery` | integer | `25` | Cap on awards returned per organization |
| `maxConcurrency` | integer | `3` | Parallel requests against NSF |
| `requestDelayMs` | integer | `0` | Optional pause between requests |
| `includeRaw` | boolean | `false` | Attach the untouched NSF record to each row |
| `proxyConfiguration` | object | proxy off | NSF answers direct requests; enable only if you need it |

**Example — one university's full award list:**

```json
{ "queries": ["Georgia Tech Research Corporation"], "maxResultsPerQuery": 100 }
```

**Example — several companies at once:**

```json
{ "queries": ["Intel Corporation", "SRI International", "Raytheon"], "maxResultsPerQuery": 50 }
```

### 📤 Output

One row per award. Fill rates below are from the measured run (51 rows, 3 organizations, 2026-09-20):

| Field | Type | Fill | Description |
|---|---|---|---|
| `companyName` | string | 100% | Awardee organization |
| `awardId` | string | 100% | NSF award id |
| `awardTitle` | string | 100% | Title of the funded project |
| `amount` | number | 100% | Funds obligated |
| `estimatedTotal` | number | 100% | NSF's estimated total for the award |
| `currency` | string | 100% | Always `USD` |
| `awardedOn` | string | 100% | Award date (ISO) |
| `startDate` / `endDate` | string | 100% | Period of performance |
| `isActive` | boolean | 100% | Whether NSF still lists the award as active |
| `address` / `state` | string | 100% | Awardee location as NSF publishes it |
| **`phone`** | string | **98%** | Awardee phone number — NSF's only direct contact field |
| `principalInvestigator` | string | 98% | PI on the award |
| `awardType` | string | 98% | NSF award instrument |
| `counterparty` | string | 98% | NSF directorate/division funding the award |
| `cfdaNumber` | string | 98% | CFDA program number |
| `city` | string | 98% | Awardee city |
| `countryName` | string | 100% | Awardee country |
| `sourceUrl` | string | 100% | Official NSF award page |
| `source` / `query` / `scrapedAt` | string | 100% | Provenance fields |

Every column above is populated on real rows — columns NSF does not publish (recipient id, award status, industry code, free-text description) were removed rather than shipped permanently empty.

**A real row from the default run:**

```json
{
  "companyName": "Intel Corporation",
  "awardId": "7469025",
  "awardTitle": "FACULTY RESEARCH PARTICIPATION",
  "amount": 6960,
  "currency": "USD",
  "awardedOn": "2004-04-13",
  "startDate": "1974-01-01",
  "endDate": "1974-11-01",
  "state": "CA",
  "isActive": false
}
```

### 💼 Use cases

- **Research-sales outreach** — build a call list of research-active organizations, phone number included
- **Grant landscape** — see which organizations NSF funds in a field, and at what scale
- **Competitor and partner mapping** — profile a university's or company's federal research income
- **PI targeting** — reach the named principal investigator on relevant awards
- **Funding trend analysis** — group awards by year, directorate or program to see where NSF money moves

### 🔗 Integration

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/nsf-awards-company-data').call({
  queries: ['Intel Corporation'], maxResultsPerQuery: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/nsf-awards-company-data").call(
    run_input={"queries": ["Intel Corporation"], "maxResultsPerQuery": 25}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**No-code:** Make, n8n and Zapier reach this Actor through the Apify app — schedule it and push new awards into a CRM or a sheet.

### 📊 Pricing

Pay-per-event: **`award-record` — $0.003 per delivered row ($3 per 1,000)**. Compute and traffic are included; you pay for rows, not run time. Rows without an award id are not charged.

[View current pricing.](https://apify.com/foxlabs/nsf-awards-company-data)

### ❓ FAQ

**Do I need an NSF API key?** No. NSF's award search is public and this Actor needs no key, login or proxy.

**Does it cover NIH or other agencies?** No — NSF only. NIH has its own record; use [NIH Grant Data](https://apify.com/foxlabs/nih-reporter-organization-data).

**Is the phone number really there?** Yes. NSF publishes the awardee's phone on the award record; it came back on 98% of rows in the measured run. It is the organization's listed number, not a personal line.

**Why do some rows have no city or PI?** NSF's older award records are thinner than recent ones. The 98% figures above reflect exactly that.

**How far back does it go?** As far as NSF's own record — the measured run returned awards starting in 1974.

**Can I search by award id instead of organization?** `queries` are organization names. For a known award, open its `sourceUrl` directly.

### 🐛 Troubleshooting

**An organization returns nothing.** NSF matches the awardee's registered name. Try the formal form (`Georgia Tech Research Corporation` rather than `Georgia Tech`).

**Fewer rows than expected.** `maxResultsPerQuery` caps per organization, not per run — raise it, or split organizations across runs.

**Amounts look small.** `amount` is the funds obligated on that award record; a large program is usually split across many awards. `estimatedTotal` carries NSF's own total estimate.

### ⚠️ Trademark

The National Science Foundation is a US federal agency. This Actor is an independent tool, is not affiliated with or endorsed by NSF or the US Government, and reads only publicly published award records.

### ⚖️ Is it legal to scrape this data?

NSF award records are published by a federal agency so the public can see how research money is spent. The rows this Actor returns describe organizations and funded projects — business and institutional information. The phone number is the organization's published contact number, not personal data. You remain responsible for how you use the output, including any outreach rules that apply to you.

### 🤝 Support & contact

Questions, a field you need, or a bug: **info@foxlabs.com.tr** — or open an issue on the Actor's Apify page.

### Changelog

#### 0.1.10

- **Fixed award dates.** NSF ships dates as US `MM/DD/YYYY`; they were parsed as `dd/mm/yyyy`, which swapped day and month and produced impossible values such as `2004-13-04`. Measured before: 39 of 51 rows invalid. Now 0.
- **Added `phone`.** NSF publishes the awardee's phone number and it was not being carried through. Measured fill: 98%.
- **Removed permanently-empty columns** (`companyId`, `status`, `industryCode`, `description`) — NSF does not publish them, so they no longer ship as null.

#### 0.1

- NSF award search by awardee organization, one row per award.
- Pay-per-event billing on delivered rows (`award-record`).

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

Awardee names (`Intel`, `Lawrence Berkeley`, `Georgia Tech Research Corporation`).

## `maxResultsPerQuery` (type: `integer`):

How many rows a single query may produce.

## `maxConcurrency` (type: `integer`):

How many queries to run at the same time. Lower it if the source throttles you.

## `includeRaw` (type: `boolean`):

Attach the source's untouched response under `raw`. Useful when you need a field this actor does not map.

## `requestDelayMs` (type: `integer`):

Politeness delay against a public source. Raise it for large runs.

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

Optional. The NSF API is open and rarely needs a proxy.

## Actor input object example

```json
{
  "queries": [
    "Intel Corporation",
    "Georgia Tech Research Corporation",
    "SRI International"
  ],
  "maxResultsPerQuery": 25,
  "maxConcurrency": 3,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "Intel Corporation",
        "Georgia Tech Research Corporation",
        "SRI International"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/nsf-awards-company-data").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 = { "queries": [
        "Intel Corporation",
        "Georgia Tech Research Corporation",
        "SRI International",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/nsf-awards-company-data").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 '{
  "queries": [
    "Intel Corporation",
    "Georgia Tech Research Corporation",
    "SRI International"
  ]
}' |
apify call foxlabs/nsf-awards-company-data --silent --output-dataset

```

## MCP server setup

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

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/jH7wTUw6KFsh4OrUU/builds/P4bFGXkI3DoOum2Bu/openapi.json