# USAspending Contracts Scraper (`acquistion-automation/usaspending-contracts-scraper`) Actor

Scrapes federal contract awards from USAspending.gov by recipient name, fiscal year, or award type group. Returns each award as a flat row with agency, amount, recipient, and award ID.

- **URL**: https://apify.com/acquistion-automation/usaspending-contracts-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![Acquisition Automation Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## 🏛 USAspending Contracts Scraper

> **Export federal awards from USAspending.gov as flat rows: recipient, awarding agency and sub-agency, award ID, award type, obligated amount, outlays to date, period of performance and a link to the award record.** No API key, no registration, no login.

USAspending.gov is the government's own record of what it has awarded and to whom. The site is built for browsing one award at a time, and its advanced search hands back a report rather than a table you can join to anything. This Actor runs the search for you, by recipient, fiscal year and award type, and writes one row per award into a dataset you can open in a spreadsheet.

| Who uses it | What they use federal award data for |
|---|---|
| 💼 Buyers of government contractors | Reading a target's actual award history, agency by agency, before trusting a revenue narrative |
| 📊 Diligence analysts | Checking concentration: how much of the book sits with one agency, one vehicle, one expiring award |
| 🎯 Sourcing and lead generation | Finding contractors in a sector by agency and award type, with the recipient name on every row |
| 🤝 Business development teams | Watching who is winning what, and when their periods of performance end |

### 📋 What it does

> 💡 **Why it matters:** a contractor's value is a book of awards with end dates on them. This puts the end dates in a column, so the cliff is visible before the LOI.

- 🔎 **Searches by recipient name**, so every award tied to a target company comes back in one run.
- 📅 **Filters by fiscal year**, or takes the current one when you leave it blank.
- 🗂 **Six award type groups**: contracts, grants, loans, direct payments, other financial assistance and IDVs.
- 🏢 **Agency and sub-agency on every row**, which is where concentration risk actually shows up.
- 💵 **Obligated amount and outlays to date**, as two separate fields rather than one blended number.
- ⏳ **Start and end dates** of the period of performance.
- 🔗 **A direct link** to the award page on USAspending for every row.
- 💾 **Exports to CSV, Excel, JSON or XML**, from the run page or the API.

### 📊 Output

Every award is one flat row with 13 fields. Amounts are in US dollars.

| Field | Type | Description |
|---|---|---|
| 🆔 `awardId` | string | The award identifier, for example a PIID such as `HT940216C0001` |
| 🏢 `recipientName` | string | Recipient as recorded, in upper case, for example `LOCKHEED MARTIN CORP` |
| 🏛 `awardingAgency` | string | Awarding department, for example `Department of Defense` |
| 🏷 `awardingSubAgency` | string | Awarding sub-agency, for example `Defense Health Agency` |
| 📄 `awardType` | string | Award type, for example `DEFINITIVE CONTRACT` |
| 💵 `awardAmount` | number | Amount obligated on the award |
| 💸 `totalOutlays` | number | Outlays recorded to date. Can be `0`, and can be negative where a de-obligation has been posted |
| 📝 `description` | string | Award description as filed. Often a procurement code rather than prose, and `null` where nothing was filed |
| 📅 `startDate` | string | Start of the period of performance, `YYYY-MM-DD` |
| ⏳ `endDate` | string | End of the period of performance, `YYYY-MM-DD` |
| 🔗 `url` | string | Direct link to the award record on USAspending.gov |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |

#### Example rows

```json
{
  "awardId": "HT940216C0001",
  "recipientName": "HUMANA GOVERNMENT BUSINESS INC",
  "awardingAgency": "Department of Defense",
  "awardingSubAgency": "Defense Health Agency",
  "awardType": "DEFINITIVE CONTRACT",
  "awardAmount": 51269205263.03,
  "totalOutlays": 0,
  "description": "IGF::OT::IGF",
  "startDate": "2016-08-01",
  "endDate": "2025-12-31",
  "url": "https://www.usaspending.gov/award/CONT_AWD_HT940216C0001_9700_-NONE-_-NONE-",
  "scrapedAt": "2026-09-14T16:37:25.505Z",
  "error": null
}
```

```json
{
  "awardId": "DEAC0494AL85000",
  "recipientName": "LOCKHEED MARTIN CORP",
  "awardingAgency": "Department of Energy",
  "awardingSubAgency": "Department of Energy",
  "awardType": "DEFINITIVE CONTRACT",
  "awardAmount": 48063737196.35,
  "totalOutlays": -4166130.71,
  "description": null,
  "startDate": "1993-10-15",
  "endDate": "2017-04-30",
  "url": "https://www.usaspending.gov/award/CONT_AWD_DEAC0494AL85000_8900_-NONE-_-NONE-",
  "scrapedAt": "2026-09-14T16:37:25.505Z",
  "error": null
}
```

Unfiltered runs come back ordered by size, so the first rows are the largest awards in the government. Set `recipientSearch` or `fiscalYear` to get the book you actually want.

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **The government's own record** | Data comes from USAspending.gov, not from a reseller's summary of it. |
| **Obligation and outlay kept apart** | `awardAmount` and `totalOutlays` are two columns, so a large award with nothing spent reads as exactly that. |
| **End dates in a column** | Period of performance sorts, which is how renewal risk gets quantified. |
| **Six award types, one schema** | Contracts, grants, loans, direct payments, other assistance and IDVs return the same 13 fields. |
| **You pay per row** | No subscription. A search that returns nothing costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Pick an `awardTypeGroup`, and set `recipientSearch` or `fiscalYear` to narrow the search.
4. Set `maxItems` to cap the run.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run:

```json
{
  "maxItems": 10,
  "awardTypeGroup": "contracts"
}
```

One company's contract history in a fiscal year:

```json
{
  "maxItems": 1000,
  "awardTypeGroup": "contracts",
  "recipientSearch": "Lockheed Martin",
  "fiscalYear": 2024
}
```

Grants instead of contracts:

```json
{
  "maxItems": 500,
  "awardTypeGroup": "grants",
  "fiscalYear": 2024
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `maxItems` | No | How many awards to collect per run. Default 10 |
| `awardTypeGroup` | No | One of contracts, grants, loans, direct_payments, other_financial_assistance, idvs. Default `contracts` |
| `recipientSearch` | No | Recipient name keyword |
| `fiscalYear` | No | Fiscal year, for example `2024`. Blank means the current fiscal year |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per award row | $0.021 | $0.0203 | $0.0197 | $0.019 | $0.019 | $0.019 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $2.10 |
| 1,000 | $21.00 |
| 10,000 | $210.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page. Schedule a monthly run per target to keep an award history that updates itself.

### 🤖 Use with an AI agent

Give an agent live access to federal award data over the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/usaspending-contracts-scraper"
```

Then ask it in plain language what a company has been awarded and have it read the result back.

### ❓ Frequently asked questions

**Does this cover grants as well as contracts?**
Yes. `awardTypeGroup` selects contracts, grants, loans, direct payments, other financial assistance or IDVs, and every group returns the same 13 fields.

**Why is `totalOutlays` zero or negative?**
Zero means no outlay has been recorded against the award yet, which is common on a newly obligated award. A negative figure reflects a de-obligation posted against earlier spending. Both come from the source.

**Why is `description` a code like `IGF::OT::IGF`, or empty?**
That is what the agency filed. Some descriptions are procurement codes, some are prose, and some were never filed, in which case the field is `null`.

**Can I search by agency?**
Not in the input. Pull a group and filter on `awardingAgency` and `awardingSubAgency` in a spreadsheet.

**How far back does the data go?**
USAspending holds awards with start dates going back decades, as the second example row shows. Set `fiscalYear` to constrain the period.

**Is `recipientSearch` an exact match?**
No. It matches a keyword in the recipient name. Recipient names are recorded in upper case and vary by legal entity, so check `recipientName` on the rows you get back before treating a total as complete.

### 🔗 More from Acquisition Automation Co.

- [SAM.gov Contract Opportunities Scraper](https://apify.com/acquistion-automation/sam-gov-contracts-scraper)
- [PublicSurplus Scraper](https://apify.com/acquistion-automation/publicsurplus-scraper)
- [IRS Exempt Organizations Scraper](https://apify.com/acquistion-automation/irs-eo-master-file-scraper)
- [USCG PSIX Vessel Registry Scraper](https://apify.com/acquistion-automation/uscg-psix-vessel-incidents-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by USAspending.gov, the Department of the Treasury or any government agency. It collects only publicly available data. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

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

How many contract awards to collect per run.

## `awardTypeGroup` (type: `string`):

Select award type group

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

Filter by recipient name keyword

## `fiscalYear` (type: `integer`):

Fiscal year (e.g. 2024). Leave empty for current fiscal year.

## Actor input object example

```json
{
  "maxItems": 10,
  "awardTypeGroup": "contracts"
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/usaspending-contracts-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/usaspending-contracts-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 '{
  "maxItems": 10
}' |
apify call acquistion-automation/usaspending-contracts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/usaspending-contracts-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/kQBnpUQlVhh7G7ymd/builds/x5FD41NFFZcSZ0ebm/openapi.json