# US Federal Contract Award Data — Who Won What, by Company (`foxlabs/usaspending-contract-award-data`) Actor

Pull every US federal contract award for a company from USAspending. Returns award ID, obligated amount, outlays, awarding agency and sub-agency, period of performance, NAICS and PSC codes, place of performance and the contract description.

- **URL**: https://apify.com/foxlabs/usaspending-contract-award-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

## US Federal Contract Award Data — Who Won What, by Company 🇺🇸

**foXLabs procurement series:** [UK Contracts Finder](https://apify.com/foxlabs/uk-contracts-finder-supplier-data) · [EU TED](https://apify.com/foxlabs/ted-tenders) · [World Bank](https://apify.com/foxlabs/worldbank-tenders) · [IADB](https://apify.com/foxlabs/iadb-tenders) · [Ukraine Prozorro](https://apify.com/foxlabs/ukraine-prozorro-tenders) · [India](https://apify.com/foxlabs/india-government-tenders)
**See also:** [US Federal Contractor profiles](https://apify.com/foxlabs/usaspending-contractor-data) — the company-level view of the same spending.

🎉 Search **US federal awards by company** and get one clean row per award — award id, title, amount, funding agency, place of performance and product/service code — straight from USAspending.gov, no key and no login.
Built for govcon sales teams, competitive analysts, and anyone who needs to know where federal dollars actually landed.

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

USAspending.gov is the US Treasury's official record of federal spending. This Actor queries it by company name and returns the individual **awards** that company received — not a summary, but the contract-level rows with amounts, agencies and performance locations.

**Use it when you need:** every federal contract a company holds; the agency mix behind a competitor's revenue; an award feed filtered by dollar floor; or grant/loan records instead of contracts (switch `awardTypes`).

**Use something else when:** you want the company-level profile — recipient totals, UEI, address — rather than award-by-award detail. Use [US Federal Contractor Data](https://apify.com/foxlabs/usaspending-contractor-data) for that. For non-US procurement, pick the matching Actor in the series above; they share the same core award schema.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/usaspending-contract-award-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/usaspending-contract-award-data with
{"queries":["Palantir"],"awardTypes":"contracts","minAmount":1000000}
and summarise the awards by funding agency.
```

### 📋 Overview

| | |
|---|---|
| **Source** | USAspending.gov (US Department of the Treasury) |
| **Coverage** | Federal contracts, grants, loans, direct payments and IDVs |
| **Auth needed** | None. No API key, no login, no proxy required |
| **Row** | One federal award |
| **Measured run** | 75 rows in 5.9 s for 3 companies (2026-09-19) |
| **Pricing** | $0.003 per delivered row — $3 per 1,000 |

### ✨ Features

- 🏢 **Company-first search** — type the recipient name, get their awards
- 💵 **Amount and outlays** — obligated value on every row, actual outlays where reported
- 🏛️ **Funding agency** on every row, so you can see which part of government buys
- 🎯 **Five award families** — contracts, grants, loans, direct payments, IDVs
- 📉 **Dollar floor** — `minAmount` filters out the noise of tiny awards
- 📍 **Place of performance** and product/service code on every row
- ⚡ **Fast and key-free** — 75 rows in under 6 seconds, no proxy

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~usaspending-contract-award-data/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Palantir","Anduril"],"awardTypes":"contracts","maxResultsPerQuery":25}'
```

### 🚀 Getting Started (3 steps)

1. **Name the companies.** Put recipient names into `queries`. The default run searches `Palantir`, `Anduril` and `Leidos`.
2. **Pick the award family.** `awardTypes` defaults to `contracts`; switch to `grants`, `loans`, `direct-payments` or `idvs`.
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 | `["Palantir","Anduril","Leidos"]` | Recipient company names to search |
| `awardTypes` | string | `contracts` | `contracts`, `grants`, `loans`, `direct-payments` or `idvs` |
| `minAmount` | integer | `0` | Skip awards below this dollar value |
| `maxResultsPerQuery` | integer | `25` | Cap on rows per company |
| `maxConcurrency` | integer | `3` | Parallel requests against USAspending |
| `requestDelayMs` | integer | `0` | Optional pause between requests |
| `includeRaw` | boolean | `false` | Attach the untouched source record to each row |
| `proxyConfiguration` | object | proxy off | USAspending answers direct requests; enable only if you need it |

**Example — only large contracts:**

```json
{ "queries": ["Leidos"], "awardTypes": "contracts", "minAmount": 10000000 }
```

**Example — research grants instead of contracts:**

```json
{ "queries": ["Johns Hopkins University"], "awardTypes": "grants", "maxResultsPerQuery": 50 }
```

### 📤 Output

One row per award. From the measured run above (75 rows, 3 companies, 2026-09-19):

| Field | Type | Fill | Description |
|---|---|---|---|
| `companyName` | string | 100% | Recipient of the award |
| `companyId` | string | 100% | Recipient identifier as published |
| `awardId` | string | 100% | Federal award id (PIID / FAIN) |
| `awardTitle` | string | 99% | Award description title |
| `awardType` | string | 100% | e.g. `DELIVERY ORDER`, `DEFINITIVE CONTRACT` |
| `awardCategory` | string | 100% | `contracts`, `grants`, … — matches your `awardTypes` input |
| `amount` | number | 100% | Obligated amount |
| `outlays` | number | 75% | Actual outlays, where USAspending reports them |
| `currency` | string | 100% | Always `USD` |
| `fundingAgency` | string | 100% | Agency funding the award |
| `counterparty` | string | 100% | Awarding office on the government side |
| `productServiceCode` | string | 100% | PSC of what was bought |
| `placeOfPerformance` | string | 100% | Where the work happens |
| `industryCode` | string | 100% | NAICS code for the award |
| `startDate` / `endDate` | string | 100% | Period of performance |
| `description` | string | 99% | Award description |
| `sourceUrl` | string | 100% | Official USAspending page for the award |
| `country` / `countryName` / `source` / `query` / `scrapedAt` | string | 100% | Provenance fields |
| `awardedOn`, `status`, `city` | string | **0%** | USAspending's search response does not carry these for award rows — the columns exist for schema parity with the procurement series and stay empty here. Use `startDate` for the contract's start |

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

```json
{
  "companyName": "PALANTIR USG INC",
  "awardId": "W9128Z26FA001",
  "awardTitle": "CDAO MSS TASK ORDER OFF OF CONTRACT W519TC25D0039",
  "awardType": "DELIVERY ORDER",
  "awardCategory": "contracts",
  "amount": 545578476.94,
  "currency": "USD",
  "countryName": "USA"
}
```

### 💼 Use cases

- **Govcon pipeline** — see which agencies buy in your category and how much they obligate
- **Competitor tracking** — every award a rival holds, with values, agencies and end dates
- **Teaming and subcontracting** — find primes with large awards in your discipline
- **Recompete timing** — `endDate` shows when a contract is up, which is when the buyer starts looking
- **Grant research** — switch `awardTypes` to `grants` and profile a university's or nonprofit's federal funding

### 🔗 Integration

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/usaspending-contract-award-data').call({
  queries: ['Palantir'], awardTypes: 'contracts', 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/usaspending-contract-award-data").call(
    run_input={"queries": ["Palantir"], "awardTypes": "contracts", "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 a recipient and an award id are not charged.

[View current pricing.](https://apify.com/foxlabs/usaspending-contract-award-data)

### ❓ FAQ

**Do I need a USAspending API key?** No. The data is public and this Actor needs no key, login or proxy.

**Does it search by company only?** Yes — `queries` are recipient names. For award-id or agency-driven research, pull a broad set and filter the output.

**Why is `awardedOn` empty?** USAspending's award search response does not include an award date for these rows. `startDate` carries the period-of-performance start, which is the closest published equivalent.

**What is the difference from the Contractor Data Actor?** This one returns individual awards. [US Federal Contractor Data](https://apify.com/foxlabs/usaspending-contractor-data) returns the company-level profile of recipients.

**Can I get grants instead of contracts?** Yes — set `awardTypes` to `grants` (or `loans`, `direct-payments`, `idvs`).

**How fresh is it?** Every run queries USAspending live. The underlying data follows the Treasury's own reporting cadence.

### 🐛 Troubleshooting

**A company returns no rows.** Federal records use the legal entity name — try the registered form (`PALANTIR USG INC` rather than `Palantir`) or drop `minAmount`.

**Fewer rows than expected.** `maxResultsPerQuery` caps per company, not per run. Raise it, or split the companies across several runs.

**Amounts look small for a big contract.** `amount` is the obligated value of that award record; a large program is often spread over many task orders and modifications.

### ⚠️ Trademark

USAspending.gov is a service of the US Department of the Treasury. This Actor is an independent tool, is not affiliated with or endorsed by the US Government, and reads only publicly published federal spending records.

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

Federal spending records on USAspending.gov are published by law under the DATA Act so the public can see where federal money goes. The rows this Actor returns are award records about organisations and public contracts — business information, not personal data. You are responsible for how you use the output.

### 🤝 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

- USAspending award search by recipient company across contracts, grants, loans, direct payments and IDVs.
- One row per award with amount, outlays, funding agency, PSC, place of performance and source URL.
- `minAmount` dollar floor; pay-per-event billing on delivered rows (`award-record`).

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/usaspending-contract-award-data/changelog.md

# Actor input Schema

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

Recipient company names (`Boeing`, `Leidos`). Awards are returned largest first.

## `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. USAspending is an open federal API and rarely needs a proxy.

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

Which kind of federal award to return.

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

Skip awards below this obligated amount. Leave at 0 for everything.

## Actor input object example

```json
{
  "queries": [
    "Palantir",
    "Anduril",
    "Leidos"
  ],
  "maxResultsPerQuery": 25,
  "maxConcurrency": 3,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "awardTypes": "contracts",
  "minAmount": 0
}
```

# 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": [
        "Palantir",
        "Anduril",
        "Leidos"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/usaspending-contract-award-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": [
        "Palantir",
        "Anduril",
        "Leidos",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/usaspending-contract-award-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": [
    "Palantir",
    "Anduril",
    "Leidos"
  ]
}' |
apify call foxlabs/usaspending-contract-award-data --silent --output-dataset

```

## MCP server setup

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