# USAspending Scraper — Federal Contract & Grant Awards (`northbell/usaspending-awards-scraper`) Actor

US federal contract and grant awards from USAspending.gov: agency, recipient organisation, amount, dates, NAICS/PSC or assistance listing, place of performance. Filter by keyword, agency, amount, state; flag awards new since your last run. Official API, no login.

- **URL**: https://apify.com/northbell/usaspending-awards-scraper.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Business, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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 Scraper — Federal Contract & Grant Awards

Search the US government's **USAspending.gov** by keyword, awarding agency, amount, state or industry code and get one clean row per award: **awarding agency and sub-agency, recipient organisation, total amount, start and end dates, NAICS and PSC codes (contracts) or Assistance Listing number (grants and loans), place of performance and award type**, with a link to the award on USAspending. **$2.00 per 1,000 awards**, no login, no API key.

Run it again, or put it on a daily schedule, and every row also tells you **whether the award is new since the last run** (`isNew`). Set *What to return* to *Only new* and you pay only for the awards you have not seen before. USAspending counted 144,130 new contracts in the 30 days to 16 Oct 2026, so the useful question is what appeared since yesterday; this keeps the list of what you have already seen.

### What you get

| Field | What it is |
|---|---|
| `awardId`, `uniqueAwardKey`, `url` | the award's own ID (contract PIID or grant FAIN), USAspending's unique key for it, and the link to its page on USAspending |
| `awardGroup`, `awardType` | `contracts`, `idvs`, `grants`, `direct-payments`, `loans` or `other-assistance`, and the award type as the source names it (`DELIVERY ORDER`, `PROJECT GRANT (B)`, `DIRECT LOAN (E)`…) |
| `isNew`, `previousRunAt` | `true` / `false` whether you had not seen this award in your previous run of the same search, and when that run was (`null` on the first run) |
| `description` | what the award is for, as the agency wrote it, cut at 500 characters (a trailing `…` marks a cut) |
| `awardingAgency`, `awardingSubAgency`, `fundingAgency`, `fundingSubAgency` | who made the award and whose budget it comes from |
| `recipientName`, `recipientUei`, `recipientCity`, `recipientState`, `recipientCountry` | the recipient **organisation**, its Unique Entity ID and its location |
| `recipientIsIndividual` | `true` when the recipient may be a person (see *Notes*): the recipient and place fields and the description are then `null` |
| `amount`, `amountKind` | `total-obligation` = the money obligated to the award so far, or `loan-face-value` for loans and loan guarantees |
| `totalOutlays`, `subsidyCost` | money actually paid out so far (where the source states it); the subsidy cost of a loan |
| `awardedOn`, `startDate`, `endDate`, `lastDateToOrder`, `lastModifiedOn` | the date the award was first signed, the period of performance (a loan's issue date is its `startDate`), the last date a framework agreement can be ordered from, and the day the record last changed |
| `naicsCode`, `naicsDescription`, `pscCode`, `pscDescription` | the industry (NAICS) and Product and Service Code of a contract |
| `assistanceListingNumber`, `assistanceListings` | the federal program of a grant, loan or payment (for example `93.671`) with its title; an award can sit under several programs, all are listed |
| `placeCity`, `placeState`, `placeZip5`, `placeCountry` | where the work is done |
| `observedAt` | when the row was collected |

### Run it again and again

- **On a schedule**: save your input as a task and add a **Schedule**: the same search every morning. Send each run to Google Sheets, Slack or email with an integration on the task.
- **Watch for changes**: Set **What to return** to *Only awards that are new since the last run*.
- **In bulk**: Combine **Keywords**, **Awarding agencies**, **States** and **NAICS / PSC codes** in one run.

### Use it for

- **Competitor and market tracking**: who wins contracts for what you sell: recipient, agency, amount and period, from a daily *Only new* feed
- **Lead lists for subcontractors and suppliers**: the prime contractors that just won work in your NAICS code or your state
- **Grant landscape**: which organisations receive money under a program (`assistanceListings`), from which agency, and how much
- **Research and journalism**: a spreadsheet of awards by agency, keyword or amount range, each linked to the official record

### Input

```json
{
  "awardType": "contracts",
  "keywords": ["cloud"],
  "agencies": ["Department of Veterans Affairs"],
  "awardedWithinDays": 30,
  "minAmount": 100000,
  "states": ["VA", "MD"],
  "maxResults": 200,
  "output": "new"
}
```

- All filters are combined with AND; the entries inside one list are combined with OR.
- **awardType**: one kind per run, because the source reports different fields for each: `contracts`, `idvs` (indefinite-delivery vehicles), `grants`, `direct-payments`, `loans`, `other-assistance`.
- **keywords**: each line is searched as a word or phrase in the award; an award that matches any line is returned.
- **agencies**: the official name or abbreviation of the top-level agency (`Department of Defense` or `DOD`). A name the Actor cannot find stops the run before anything is charged.
- **awardedWithinDays**, **startDate**, **endDate**, **dateBasis** — *New awards* (default) means the award was first signed in the period. *Latest action* also returns older awards that were modified in the period.
- **minAmount**, **maxAmount** — in US dollars, on the total obligation (loans: face value).
- **states**: the place of performance, two-letter codes.
- **naicsCodes**, **pscCodes** — contracts and IDVs; a shorter code covers its whole branch. **assistanceListings** — grants, direct payments, loans and other assistance, in the form `10.331`.
- Results are sorted newest first (or largest first), and **maxResults** (default 100, up to 5,000) cuts the list. With *Only new* it is the number of new awards to return: the Actor reads down the list, past the awards you have already seen (up to 5,000 awards deep), until it has found that many. Awards below the cut-off are not marked as seen, so they come back as new in your next run.

"Is it new" is remembered per search — the same award type, keywords, agencies, states, codes and amounts — in a named key-value store in your Apify account, so the second run of the same search already shows `isNew`. Changing *Awarded within*, *Maximum awards* or the sort order keeps the same history.

### Pricing

**$2.00 per 1,000 awards**, plus $0.01 per run. Error rows (a search USAspending rejects, USAspending not answering) are free. With *Only new*, awards you have already seen are skipped and not charged. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- Source: the public search API of USAspending.gov, the US Department of the Treasury's federal spending site. The API documents that its endpoints need no authorization, and nothing from behind a login is read. I found no licence or terms-of-use text on USAspending.gov or in its API documentation that restricts reuse of the data, and its API code is published under CC0; the federal data is listed on Data.gov with public access level. The Actor identifies itself in its requests and pauses 0.7 seconds between them. This Actor is not affiliated with or endorsed by the US Department of the Treasury.
- **Recipients who may be people.** Awards to individuals (some grants and payments) are already masked in the source as `INDIVIDUAL RECIPIENT`. In addition, for every page the Actor asks USAspending which of those awards went to a recipient registered as an individual or a sole proprietorship; for those rows `recipientName`, `recipientUei`, the recipient and place-of-performance fields and `description` are `null` and `recipientIsIndividual` is `true`. The check is deliberately broad: it also catches companies that registered as sole proprietorships, so some company names are withheld too (10 of 500 contracts in a live read on 16 Oct 2026, none of 500 grants). If the check cannot be answered, that page is not output (a free error row says so). Free text can still name a person inside an organisation's description, so check descriptions before you republish them.
- No contact persons, emails or phone numbers are returned; the Actor never asks for them, and emails or international phone numbers that appear inside a description are removed.
- In a live read of 500 new contracts on 16 Oct 2026: `naicsCode` and `pscCode` were filled on all 500, `description` on 490, `recipientUei` on 490 and `placeState` on 487. `amount` was 0 or less on 9 of the 500, so filter small amounts before you add them up. Of 500 new grants, `assistanceListingNumber` was filled on all 500, and 293 descriptions were longer than 500 characters and were cut.
- `amount` is what has been obligated so far, not the ceiling of a framework agreement. Use *Latest action* if you want awards that were modified in the period; the same award then shows its current amount.
- **Defense contracts arrive late.** In a live count on 16 Oct 2026, awarding agency `Department of Defense` had 16 new contracts in the last 30 days and 48 in the last 90, against 240,357 in the last 120 days; all agencies together had 144,130 in the last 30 days. For DOD, use a period of 120 days or more.
- The source cannot search before 2007-10-01.
- A live read of 500 contracts took 11 seconds and 500 grants 12 seconds on 16 Oct 2026.
- If USAspending is rate limiting or unavailable, the Actor waits and retries twice. If it still gets no answer it adds a free error row, and the run is marked failed when nothing at all could be read.

For the European equivalent, see [EU Tenders Scraper (TED)](https://apify.com/northbell/eu-tenders-ted-search). To find US federal funding you can still apply for, see [Grants.gov Scraper](https://apify.com/northbell/grants-gov-opportunities-scraper). If the winner of an award is a UK company, see [UK Companies House Scraper](https://apify.com/northbell/companies-house-search) for its register entry.

### For AI agents

`{"awardType": "contracts", "keywords": ["cloud"], "awardedWithinDays": 30, "maxResults": 5}` returns up to 5 rows, newest first, each with agency, recipient organisation, amount and dates. Rows have `type`: `award` or `error`. Fields that do not apply to an award are `null` (or an empty list), never missing. Schedule the same input daily with `"output": "new"` to get only what was signed since the previous run.

# Actor input Schema

## `awardType` (type: `string`):

One kind per run, because the source reports different fields for each. Contracts and IDVs have NAICS and PSC codes; grants, direct payments, loans and other assistance have an Assistance Listing number (the old CFDA number).

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

Words or phrases to match against the award (its description and other text fields). One per line; an award that matches any line is returned. A line with several words is searched as a phrase, e.g. "cloud computing". Leave empty to skip.

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

Top-level federal agencies that made the award, one per line: the official name or the abbreviation, e.g. "Department of Defense" or "DOD", "NASA", "HHS". An unknown name stops the run before anything is charged. Leave empty for all agencies.

## `subAgencies` (type: `array`):

Sub-agencies or offices that made the award, one per line, spelled exactly as in the results (awardingSubAgency), e.g. "Defense Information Systems Agency". Combined with the agencies above with OR. Leave empty to skip.

## `awardedWithinDays` (type: `integer`):

Only awards in the last N days, counted by the date basis below. Ignored when you set a start date. Defense (DOD) contract data is published with a delay of about 90 days, so use a longer period for DOD.

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

First day to include, as YYYY-MM-DD, e.g. 2026-09-01. Replaces "Awarded within (days)". The source cannot search before 2007-10-01.

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

Last day to include, as YYYY-MM-DD. Leave empty for today.

## `dateBasis` (type: `string`):

"New awards" gives awards that began in the period. "Latest action" also returns older awards that were modified in it, so the same award can come back with a larger amount.

## `minAmount` (type: `number`):

Only awards with a total obligation (for loans: face value) of at least this many US dollars.

## `maxAmount` (type: `number`):

Only awards with a total obligation (for loans: face value) of at most this many US dollars.

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

Only awards whose work is done in these states, as two-letter codes, one per line: VA, CA, TX, PR, DC … Leave empty for everywhere.

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

Only contracts in these industries, 2 to 6 digits, one per line, e.g. 5415 for computer systems design. A shorter code covers its whole branch. Contracts and IDVs only.

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

Only contracts with these Product and Service Codes, 1 to 4 characters, one per line, e.g. D3 for IT and telecom services or D302. A shorter code covers its whole branch. Contracts and IDVs only.

## `assistanceListings` (type: `array`):

Only awards under these federal programs, one per line, in the form 10.331 (the old CFDA numbers). Grants, direct payments, loans and other assistance only.

## `recipients` (type: `array`):

Words from the recipient organisation's name, or its UEI number, one per line. An award matching any line is returned. Awards to individuals never show a name, so they cannot be found this way.

## `sortBy` (type: `string`):

Which awards you get when more match than "Maximum awards". Newest first is what you want for a daily feed.

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

How many awards to return. You pay per award returned. With "Only new" the Actor reads past the awards you have already seen until it has found this many new ones. Narrow the search with the filters above rather than raising this.

## `output` (type: `string`):

With "Only new", awards you already got in an earlier run of the same search are skipped and not charged. The first run returns everything, because there is nothing to compare with yet.

## Actor input object example

```json
{
  "awardType": "contracts",
  "keywords": [
    "cloud"
  ],
  "awardedWithinDays": 30,
  "dateBasis": "new-awards",
  "sortBy": "newest",
  "maxResults": 100,
  "output": "all"
}
```

# Actor output Schema

## `awards` (type: `string`):

Agency, recipient, amount, dates, codes and place for each award.

# 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 = {
    "awardType": "contracts",
    "keywords": [
        "cloud"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/usaspending-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 = {
    "awardType": "contracts",
    "keywords": ["cloud"],
}

# Run the Actor and wait for it to finish
run = client.actor("northbell/usaspending-awards-scraper").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 '{
  "awardType": "contracts",
  "keywords": [
    "cloud"
  ]
}' |
apify call northbell/usaspending-awards-scraper --silent --output-dataset

```

## MCP server setup

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

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/IVb7Ih6gIBlKEDOdG/builds/KjSpqsa7QDh3bXCd7/openapi.json