# USAspending Scraper | 6 Award Types, 18 Fields, No Key (`themineworks/usaspending-federal-awards`) Actor

Scrape every US federal contract, grant, loan & award from USAspending.gov as clean JSON. Filter by keyword, agency, NAICS, recipient, amount & state. GovCon & B2G intelligence. No API key. Works in Claude, ChatGPT & any MCP agent.

- **URL**: https://apify.com/themineworks/usaspending-federal-awards.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Business, Lead generation, MCP servers
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 award scrapeds

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: 6 Award Types, 18 Fields, No Key

Pay only for results delivered. [Browse all Actors](https://apify.com/themineworks?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral).

💰 From $0.60 / 1,000 results.

Guide and FAQs: [USAspending Federal Awards on themineworks.com](https://themineworks.com/actors/usaspending-federal-awards/). Tutorial: [USASpending API: Pull Federal Contracts and Grants in Python](https://themineworks.com/blog/usaspending-federal-contracts-api/).

Every US federal contract, grant, loan and direct payment, filterable by agency, recipient, NAICS, state and dollar amount. 18 fields per award, no API key.

### Why use this federal awards scraper

USAspending.gov publishes every dollar the US federal government awards, but its search API expects award-type code arrays, tiered agency objects and field lists that differ depending on what you are asking for. This actor takes plain inputs and builds that request for you.

**Six award categories** are supported, each mapping to the correct set of USAspending type codes: `contracts`, `idvs` (indefinite delivery vehicles), `grants`, `direct_payments`, `loans` and `other_assistance`. Pick one per run.

**Eight filters compose freely**: keywords, awarding agency, recipient name, NAICS codes, place-of-performance state, minimum amount, maximum amount and a date window. Results come back sorted by award amount descending, so the biggest awards arrive first and a modest `maxResults` still gives you the ones that matter.

Contract and IDV runs additionally carry NAICS and PSC codes with their descriptions. Assistance awards carry the assistance award type instead, because that is what USAspending exposes for them.

**No API key.** USAspending's API is fully open.

### Find the largest federal contracts in a category

Keywords search across award descriptions and recipient names. Results are sorted by award amount descending, so this returns the biggest matching contracts first.

```json
{
  "keywords": [
    "cybersecurity"
  ],
  "awardType": "contracts",
  "maxResults": 200,
  "dateFrom": "2025-01-01"
}
```

### Track every award to one recipient

`recipientSearch` matches the recipient name. Use it to build a company's full federal revenue picture across agencies.

```json
{
  "recipientSearch": "Booz Allen Hamilton",
  "awardType": "contracts",
  "dateFrom": "2024-01-01",
  "maxResults": 500
}
```

### Pull grants from a specific agency in a state

Agency names must match how USAspending lists them, for example `Department of Health and Human Services`. `placeOfPerformanceState` takes a two-letter code.

```json
{
  "awardType": "grants",
  "agencies": [
    "Department of Health and Human Services"
  ],
  "placeOfPerformanceState": "CA",
  "minAmount": 1000000,
  "maxResults": 300
}
```

### Filter contracts by industry code and dollar band

`naicsCodes` only applies to contract-like award types. Combine with `minAmount` and `maxAmount` to isolate a specific deal size in a specific industry.

```json
{
  "awardType": "contracts",
  "naicsCodes": [
    "541512"
  ],
  "minAmount": 500000,
  "maxAmount": 10000000,
  "dateFrom": "2025-06-01",
  "dateTo": "2026-06-01",
  "maxResults": 400
}
```

### What data you get back

18 fields per award.

| Field | What it is |
| --- | --- |
| `award_id` | USAspending award identifier |
| `recipient_name` | Awarded organisation |
| `recipient_id` | USAspending's internal recipient id |
| `awarding_agency` | Top-tier awarding agency |
| `awarding_sub_agency` | Sub-agency |
| `award_amount` | Dollar amount, as a number |
| `award_type` | Contract award type, or assistance award type |
| `award_category` | The category you requested |
| `naics` | NAICS industry code, contracts and IDVs only |
| `naics_description` | Plain-English NAICS description |
| `psc` | Product or service code, contracts and IDVs only |
| `psc_description` | Plain-English PSC description |
| `start_date` | Period of performance start |
| `end_date` | Period of performance end |
| `place_of_performance_state` | State code where the work happens |
| `description` | Award description text |
| `award_url` | Direct link to the award page on usaspending.gov |
| `scraped_at` | ISO timestamp of capture |

Records also carry `internal_id` and `agency_slug` where USAspending returns them. A final `_type: "summary"` reports the category, the award count, the date window used and the charged count.

### How it works

The actor posts to `api.usaspending.gov/api/v2/search/spending_by_award/`, translating your `awardType` into the matching USAspending type-code array and requesting only the fields valid for that group. Contracts and IDVs get NAICS and PSC; assistance types get the award type instead.

Results page 100 at a time, sorted by award amount descending, and stop when your `maxResults` is met or USAspending reports no next page.

If you do not set `dateFrom`, the window defaults to the last 365 days. Dates before 2007-10-01 are clamped, since that is where USAspending's coverage begins.

NAICS and PSC arrive from the API as objects rather than strings; the code and description are split into separate fields so the values stay usable.

### Who uses federal awards data

**GovCon business development.** Find who is winning work in your NAICS, at what size, for which agency, and how their period of performance is running out.

**Competitor analysis.** `recipientSearch` on a competitor returns their federal revenue by agency and by industry code.

**Grant research.** Filter grants by agency, state and minimum amount to find funders active in a programme area.

**Economic and policy research.** Aggregate spend by state, agency or industry code over a date window.

### What it costs

One pay-per-event charge, `award-scraped`, billed per award that actually lands in your dataset. Your rate depends on your own Apify discount tier:

| Your Apify tier | Per award | Per 1,000 |
| --- | --- | --- |
| FREE | $0.0035 | $3.50 |
| BRONZE | $0.00315 | $3.15 |
| SILVER | $0.0028 | $2.80 |
| GOLD / PLATINUM / DIAMOND | $0.0025 | $2.50 |

Nothing else is billed. Failed requests, blocked pages, empty searches and error records are never charged, so a run that returns no awards costs nothing. There is no subscription and no monthly minimum.

### Run it on a schedule

Scheduled runs are the pattern most people end up on: smaller, more frequent runs finish faster, keep the data fresh, and cost exactly the same per record as one big run.

1. On this actor's page, click **... -> Schedule Actor** (or Console -> **Schedules -> Create new**).
2. Pick a frequency. `@daily` suits most standing queries.
3. Your saved input is reused on every run and each run appends to the dataset.
4. Wire the dataset to Google Sheets, Slack, or a webhook from the **Integrations** tab so new rows reach you without you looking.

### FAQ

**Do I need a USAspending API key?**
No. The API is fully open.

**Can I mix award types in one run?**
No. `awardType` takes one category per run because USAspending's field list differs by category. Run once per category and combine downstream.

**Why is `naics` empty on my results?**
NAICS and PSC only exist for contracts and IDVs. Grants, loans, direct payments and other assistance do not carry them.

**How far back does the data go?**
USAspending's coverage starts 2007-10-01, and dates earlier than that are clamped to it.

**How do I write agency names?**
Exactly as USAspending lists them, for example `Department of Defense` or `Department of Health and Human Services`. They match top-tier awarding agencies.

**Are results sorted?**
Yes, by award amount descending. So even a small `maxResults` returns the largest matching awards.

**What if nothing matches?**
The run logs it, writes a summary and charges nothing.

### Use it from Claude, ChatGPT and any MCP agent

Hosted MCP endpoint, no install, OAuth on first connect:

```
https://mcp.apify.com/?tools=themineworks/usaspending-federal-awards
```

Claude Desktop / Cursor config with token auth:

```json
{
  "mcpServers": {
    "usaspending": {
      "url": "https://mcp.apify.com/?tools=themineworks/usaspending-federal-awards",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Or call it from code with the Apify client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/usaspending-federal-awards').call({
  "keywords": [
    "cybersecurity"
  ],
  "awardType": "contracts",
  "maxResults": 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Related actors

- **[SAM.gov Contracts Scraper](https://apify.com/themineworks/sam-gov-contracts?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**: the opportunities side, before the award is made.
- **[SEC EDGAR Filings Scraper](https://apify.com/themineworks/sec-edgar-filings?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**: what the public recipients tell their investors.
- **[Federal Register Scraper](https://apify.com/themineworks/federal-register?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**: the rules and notices behind the programmes.
- **[FEC Campaign Finance](https://apify.com/themineworks/fec-campaign-finance?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**: political contribution data on the same organisations.

***

**Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the U.S. Department of the Treasury or USAspending.gov. It uses the public USAspending API. Award data is published by the US federal government.

Found a bug or want a field added? Open an issue from the actor's Apify Console page or reach out through the [The Mine Works profile](https://apify.com/themineworks?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral).

### Related guides

- [Federal Contract Intelligence: Track Government Awards with the USAspending API](https://themineworks.com/blog/usaspending-federal-contracts-api)
- [USASpending.gov API: How to Pull Federal Contracts, Grants, and Awards Programmatically](https://themineworks.com/blog/usaspending-federal-contracts-api)

*Last verified: 2026-08*

# Actor input Schema

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

Free-text search across award descriptions, recipients and identifiers (e.g. cybersecurity, solar, ambulance). Leave empty to match all awards in your other filters.

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

Which category of federal award to return.

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

Top-tier awarding agency names to filter by, exactly as USAspending lists them (e.g. Department of Defense, Department of Health and Human Services). Leave empty for all agencies.

## `recipientSearch` (type: `string`):

Filter to awards whose recipient name matches this text (e.g. Lockheed). Leave empty for all recipients.

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

Industry NAICS codes to filter by (e.g. 541512). Applies to contracts and IDVs only.

## `placeOfPerformanceState` (type: `string`):

Two-letter US state code where the work is performed (e.g. CA, TX, VA). Leave empty for all states.

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

Only return awards at or above this dollar amount.

## `maxAmount` (type: `integer`):

Only return awards at or below this dollar amount.

## `dateFrom` (type: `string`):

Earliest award action date. USAspending search supports dates back to 2007-10-01. Defaults to the last 365 days if left empty, e.g. "2024-01-01".

## `dateTo` (type: `string`):

Latest award action date. Defaults to today if left empty, e.g. "2024-12-31".

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

Maximum number of awards to return, sorted by amount (largest first).

## Actor input object example

```json
{
  "keywords": [
    "cybersecurity"
  ],
  "awardType": "contracts",
  "agencies": [
    "Department of Defense"
  ],
  "dateFrom": "2024-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 25
}
```

# Actor output Schema

## `results` (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 = {
    "keywords": [
        "cybersecurity"
    ],
    "awardType": "contracts",
    "agencies": [
        "Department of Defense"
    ],
    "dateFrom": "2024-01-01",
    "dateTo": "2024-12-31",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/usaspending-federal-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 = {
    "keywords": ["cybersecurity"],
    "awardType": "contracts",
    "agencies": ["Department of Defense"],
    "dateFrom": "2024-01-01",
    "dateTo": "2024-12-31",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/usaspending-federal-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 '{
  "keywords": [
    "cybersecurity"
  ],
  "awardType": "contracts",
  "agencies": [
    "Department of Defense"
  ],
  "dateFrom": "2024-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 25
}' |
apify call themineworks/usaspending-federal-awards --silent --output-dataset

```

## MCP server setup

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