# USAspending Federal Contract Awards Scraper — GovCon Leads (`parallelstudio/usaspending-contract-awards`) Actor

Find GovCon leads and competitors: federal contract awards from USAspending.gov back to FY2008 with winner, UEI, agency, amount and NAICS. Filter by state, NAICS, agency, set-aside or company, find recompetes, or run weekly with onlyNew (no repeat charges). $0.004/award, no start fee.

- **URL**: https://apify.com/parallelstudio/usaspending-contract-awards.md
- **Developed by:** [Parallel Studio](https://apify.com/parallelstudio) (community)
- **Categories:** Lead generation, Other
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 96.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 awards

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

## USAspending Federal Contract Awards Scraper — GovCon Leads

Search **USAspending.gov** for awarded U.S. federal **contracts, IDVs and grants** by place-of-performance state, keywords, NAICS, PSC, awarding agency, recipient company/UEI, small-business set-aside, amount and date, or find **contracts expiring soon** (recompete leads). You get one clean row per award, largest first, with the winning company, its UEI, the agency, the dollar value and a direct link to the award. Built for GovCon lead generation, teaming and competitor research.

**Who it's for:** government contractors, BD teams and B2B sellers who need to see who won federal contracts in their state or NAICS code, and which contracts expire soon, at $0.004 per award.

### What you can answer with it

- Which companies won federal construction contracts in Minnesota this year?
- Who are the biggest prime contractors in my NAICS code in my state?
- Which agencies are buying cybersecurity, janitorial or engineering work near me?
- Which firms just won large awards and may need subcontractors, suppliers or staff?
- Which DoD small-business set-aside contracts in my state end in the next 6 months (recompete leads)?
- What has a competitor (by name or UEI) won, from which agencies?

### Output

awardId, recipient, recipientUei, amount, outlays, agency, subAgency, startDate, endDate, description, NAICS, PSC, awardType, place-of-performance state and ZIP, a direct USAspending award link, and `daysUntilEnd` (days from the run date until `endDate`; negative = already ended, null = no end date).

### Data quality & coverage (measured 2026-10-13 from the USAspending API)

- **History:** contract data goes back to FY2008. Minnesota alone had 42,532 contract awards with activity in calendar 2008 and 44,548 in FY2025.
- **Freshness:** 4,659 Minnesota contract awards and 524,135 nationwide had activity in the last 90 days (Jul 14 to Oct 12, 2026).
- **Field completeness** on the 500 largest Minnesota contract awards of 2026: award ID, recipient, UEI, amount, agency, sub-agency, start and end dates, description, NAICS, PSC, award type and place-of-performance ZIP are all **100% filled**. Total outlays are filled on 55.6% (USAspending only reports outlays once money is paid out).
- **Source of truth:** every row links back to its official USAspending award page, so you can verify any record.

### Input

| Field | What it does |
|---|---|
| `state` | Two-letter place-of-performance state (MN, TX, VA...). Empty = all states. |
| `keywords` | Words matched against descriptions and recipients, e.g. `construction`. |
| `awardTypes` | `contracts`, `idvs` (IDIQs, GWACs, BPAs) or `grants`. |
| `startDate` / `endDate` | Action date range (YYYY-MM-DD). End empty = today. |
| `naicsCodes` | 6-digit NAICS codes to require (contracts and IDVs only). |
| `minAmount` | Minimum award value in dollars. |
| `maxItems` | Maximum awards returned. |
| **GovCon lead filters** | *(all optional)* |
| `agencies` | Awarding top-tier agencies, e.g. `Department of Defense`, `General Services Administration`. Case-insensitive; abbreviations like `DOD` or `VA` work. |
| `recipientSearch` | Company name fragments or UEIs, e.g. `Lockheed` or `MM6CKLE6NK34`. |
| `pscCodes` | Product/Service Codes, full (`R425`) or prefix (`R4`). Contracts and IDVs only. |
| `setAsideTypes` | Set-aside codes: `SBA`, `SBP`, `8A`, `8AN`, `HZC`, `HZS`, `SDVOSBC`, `SDVOSBS`, `WOSB`, `WOSBSS`, `EDWOSB`, `EDWOSBSS`, `VSA`, `VSS`, `ISBEE`, `IEE`, `BI`, `NONE`. Contracts and IDVs only. |
| `newAwardsOnly` | `true` = only awards first signed in the date range, not older awards that were just modified. |
| `expiringWithinDays` | Recompete mode: only awards whose current end date falls between today and today + N days, sorted soonest first. `0` = off. |
| `daysBack` | Rolling window: when above `0`, the action-date start is today minus N days (UTC) and overrides `startDate`. Default `0` = use `startDate`. |
| `onlyNew` | Incremental mode: skip awards already delivered by earlier runs with the same filters, so repeat runs are not charged twice. Default `false`. |

### Example input

```json
{
  "state": "MN",
  "keywords": [
    "construction"
  ],
  "awardTypes": "contracts",
  "startDate": "2026-01-01",
  "naicsCodes": [
    "236220"
  ],
  "minAmount": 100000,
  "maxItems": 100
}
```

### Recompete leads: contracts expiring soon

Set `expiringWithinDays` to get awards whose current period of performance ends within the next N days, soonest first. These are contracts that the agency will soon re-buy, extend or re-compete, so they are good leads for capture planning and for contacting the incumbent about teaming.

```json
{
  "state": "MN",
  "agencies": ["Department of Defense"],
  "setAsideTypes": ["SBA"],
  "startDate": "2025-10-01",
  "minAmount": 250000,
  "expiringWithinDays": 180,
  "maxItems": 100
}
```

Tips:

- Note that `startDate`/`endDate` still filter on action date, so an award only shows up if it had activity in that range. Use an earlier `startDate` to include long-running contracts with no recent modifications.
- USAspending has no end-date filter, so the actor sorts by end date and scans pages (at most 50 pages of 100 awards per run). The API only pages through the first 50,000 matches (limit checked 2026-10-16). With very broad searches (e.g. all states, all agencies) every one of those ended in the past, so the actor logs a warning and asks you to add filters such as state, agency, NAICS, PSC or `minAmount`.
- An end date is the *current* end of the period of performance. Unexercised options can still extend it.

### Example output (real record from the 2026-10-12 cloud run; `daysUntilEnd` as of 2026-10-16)

```json
{
  "awardId": "47PB5226C0001",
  "recipient": "MCGOUGH CONSTRUCTION CO., LLC",
  "recipientUei": "MM6CKLE6NK34",
  "amount": 107620021.44,
  "outlays": 4930783,
  "agency": "General Services Administration",
  "subAgency": "Public Buildings Service",
  "startDate": "2025-10-29",
  "endDate": "2029-06-05",
  "description": "DESIGN BUILD SERVICES FOR THE NEW LAND PORT OF ENTRY (LPOE) LOCATED IN GRAND PORTAGE, MINNESOTA",
  "naics": "236220 COMMERCIAL AND INSTITUTIONAL BUILDING CONSTRUCTION",
  "psc": "Y1AZ CONSTRUCTION OF OTHER ADMINISTRATIVE FACILITIES AND SERVICE BUILDINGS",
  "awardType": "DEFINITIVE CONTRACT",
  "popState": "MN",
  "popZip": "55605",
  "url": "https://www.usaspending.gov/award/CONT_AWD_47PB5226C0001_4740_-NONE-_-NONE-",
  "daysUntilEnd": 963
}
```

### Pricing

Pay per event: **$0.004 per USAspending award** returned, no start fee. 100 awards cost $0.40 and 1,000 awards cost $4.

What real searches cost, from USAspending award counts measured on Oct 21, 2026 (contracts, place of performance):

| Search | Awards | Cost |
|---|---|---|
| Minnesota, last 7 days (a weekly `daysBack: 7` + `onlyNew` feed) | 175 | about $0.70/week |
| Texas, last 7 days | 343 | about $1.37/week |
| California, last 7 days | 958 | about $3.83/week |
| Virginia, last 7 days | 1,228 | about $4.91/week |
| Minnesota, last 30 days, $1M and up (`minAmount: 1000000`) | 79 | about $0.32 |
| Minnesota, last 30 days, any amount | 1,281 | about $5.12 |
| Minnesota, all of 2026 so far | 26,396 | about $105.58 |

`maxItems` caps every run, so you never pay for more rows than you set. Narrow with `naicsCodes`, `minAmount` or `agencies` to cut cost further.

### FAQ

**Is this the same as SAM.gov?** No. SAM.gov lists open opportunities and registrations. USAspending shows money that was actually awarded, so you see who won, for how much and from which agency.

**Does "state" mean where the company is based?** It means where the work is performed. A Virginia firm doing work in Minnesota shows up under MN.

**How do I find subcontracting leads?** Filter by your state and NAICS code with a minimum amount (say $1M). The largest primes come first, and each row has the recipient UEI so you can look them up in SAM.gov.

**Can I schedule it?** Yes. Schedule it weekly with `daysBack` 7 (or 14 to cover reporting lag) plus `onlyNew` true, so each run returns only awards it has not delivered before and you are not charged twice.

**How do I get the awards into Google Sheets, my CRM or Slack?** Every run saves a dataset you can download as CSV, Excel or JSON, or read through the Apify API. To automate it, put the actor on an Apify schedule and connect one of Apify's integrations (Google Sheets, Slack, email, Zapier, Make or a webhook) so each week's new awards land in your pipeline tracker.

**How do I find recompete leads (contracts expiring soon)?** Set `expiringWithinDays` (e.g. 180) together with a state, agency, NAICS or PSC filter. You get the awards ending soonest first, with `daysUntilEnd` on every row. See "Recompete leads" above.

**Can I search for a competitor?** Yes. Put their name or UEI in `recipientSearch` and clear `state` to see everything they won nationwide.

**Why is a statewide search mostly defense contracts?** Results come largest first, and in Minnesota the largest awards are mostly defense. In the 100 largest Minnesota contract awards with activity since Jan 1, 2026 (default input, measured 2026-10-25), the Department of Defense had 68 awards and 79% of the dollars, and 21 were under NAICS 332993 (ammunition manufacturing). Only 8 of the 100 started in 2026; the rest are older contracts with new modifications. To reach your niche, add `naicsCodes` (for example 541330 engineering services or 236220 commercial building construction), `keywords` or `agencies`. For recompete leads, add `expiringWithinDays`: 13 of those 100 end within 180 days.

**Why is outlays sometimes empty?** USAspending only fills outlays after payments are made, so new awards often have none yet.

### Source

Public-domain U.S. government data via the official [USAspending API](https://api.usaspending.gov/?utm_source=apify\&utm_medium=listing\&utm_campaign=usaspending-contract-awards).

### Related actors

Other public-data Actors from parallelstudio:

- [Minneapolis building permits since 2016: contractor, valuation, address, ward, neighborhood](https://apify.com/parallelstudio/twin-cities-building-permits) ($0.004/permit)
- [Bulk Shopify app and theme detector for store URLs](https://apify.com/parallelstudio/shopify-store-tech-detector) ($0.01/store)
- [CPSC and FDA food, drug and device recalls in one schema, plus opt-in NHTSA vehicle recalls](https://apify.com/parallelstudio/us-product-recalls-unified) ($0.003/recall)

# Actor input Schema

## `state` (type: `string`):

Two-letter U.S. state code for where the work is performed (place of performance), e.g. MN, TX, VA. Leave empty to search all states.

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

Optional words matched against award descriptions and recipient names, e.g. "construction", "cybersecurity", "snow removal". Several keywords widen the search.

## `awardTypes` (type: `string`):

contracts = definitive contracts, purchase orders, delivery/task orders, BPA calls. idvs = indefinite-delivery vehicles (IDIQs, GWACs, BPAs, FSS). grants = block, formula, project and cooperative-agreement grants.

## `startDate` (type: `string`):

Earliest action date to include (YYYY-MM-DD). USAspending contract data reaches back to FY2008.

## `endDate` (type: `string`):

Latest action date to include (YYYY-MM-DD). Leave empty for today.

## `naicsCodes` (type: `array`):

Optional 6-digit NAICS codes to require, e.g. 236220 (commercial building construction), 541511 (custom programming). Ignored for grants.

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

Only return awards worth at least this many dollars. Results are sorted largest award first (or soonest-ending first in recompete mode).

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

Maximum number of awards to return. You pay $0.004 per award, so 100 awards cost $0.40.

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

Top-tier awarding agency names, e.g. "Department of Defense", "Department of Veterans Affairs", "General Services Administration". Case does not matter; common abbreviations like DOD or VA also work. Several agencies widen the search.

## `recipientSearch` (type: `array`):

Find awards won by specific companies: enter part of a company name (e.g. "Lockheed") or a 12-character UEI. Great for competitor research. Several entries widen the search.

## `pscCodes` (type: `array`):

Product/Service Codes to match, 1-4 characters. A full code (R425 = engineering/technical support) or a prefix (R4, or R for all services) both work. Contracts and IDVs only; ignored for grants.

## `setAsideTypes` (type: `array`):

Only return awards made under these small-business set-asides, e.g. SBA total small business, 8(a), HUBZone, SDVOSB, WOSB. Contracts and IDVs only; ignored for grants.

## `newAwardsOnly` (type: `boolean`):

Only return awards first signed within the action date range, instead of any award with activity (e.g. a modification) in that range.

## `expiringWithinDays` (type: `integer`):

Recompete mode. Only return awards whose current period of performance ends between today and today + N days (e.g. 180), sorted soonest-ending first. Combine with state, agency, NAICS, PSC or minAmount filters. Scans at most 50 pages (5,000 awards) per run and logs a warning if that is not enough.

## `daysBack` (type: `integer`):

Rolling window for scheduled runs. When above 0, the action date start becomes today minus N days (UTC) and overrides "Action date from". Use 7 for weekly runs, or 14 to cover reporting lag. 0 = use "Action date from".

## `onlyNew` (type: `boolean`):

Incremental mode for schedules. Remembers the awards already delivered (per set of filters, in a named key-value store) and skips them, so each run returns only awards you have not received before and you are not charged twice. Pair with "Only last N days".

## Actor input object example

```json
{
  "state": "MN",
  "keywords": [
    "construction"
  ],
  "awardTypes": "contracts",
  "startDate": "2026-01-01",
  "naicsCodes": [
    "236220"
  ],
  "minAmount": 100000,
  "maxItems": 100,
  "agencies": [],
  "recipientSearch": [],
  "pscCodes": [],
  "setAsideTypes": [],
  "newAwardsOnly": false,
  "expiringWithinDays": 0,
  "daysBack": 0,
  "onlyNew": false
}
```

# Actor output Schema

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

All records from the default dataset (JSON/CSV/Excel via the dataset API).

# 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 = {
    "state": "MN",
    "keywords": [
        "construction"
    ],
    "startDate": "2026-01-01",
    "naicsCodes": [
        "236220"
    ],
    "minAmount": 100000,
    "maxItems": 100,
    "agencies": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("parallelstudio/usaspending-contract-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 = {
    "state": "MN",
    "keywords": ["construction"],
    "startDate": "2026-01-01",
    "naicsCodes": ["236220"],
    "minAmount": 100000,
    "maxItems": 100,
    "agencies": [],
}

# Run the Actor and wait for it to finish
run = client.actor("parallelstudio/usaspending-contract-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 '{
  "state": "MN",
  "keywords": [
    "construction"
  ],
  "startDate": "2026-01-01",
  "naicsCodes": [
    "236220"
  ],
  "minAmount": 100000,
  "maxItems": 100,
  "agencies": []
}' |
apify call parallelstudio/usaspending-contract-awards --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parallelstudio/usaspending-contract-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/Xy7aFKpePclTqTvtE/builds/h2StaH2s59Qqc8rwY/openapi.json