# Federal Contract Awards Feed (USAspending) (`moment-data/federal-contract-awards-feed`) Actor

New federal contract and IDV awards since your last run, filtered by NAICS, PSC, state, agency, set-aside and amount. Official USAspending.gov API, no key.

- **URL**: https://apify.com/moment-data/federal-contract-awards-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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 Awards: Daily New-Awards Feed

Get **only the federal contracts you have not seen yet**, straight from the official [USAspending.gov](https://www.usaspending.gov) API. Schedule it daily and every run delivers the awards that appeared since the last one, filtered to your market.

### What you get

- **New since last run**: the Actor remembers which awards it already delivered (per *State key*), so a daily schedule pays only for new records.
- **Filter like a capture manager**: NAICS, PSC, place-of-performance state, awarding agency, set-aside type, recipient watchlist (competitors, primes), keywords, min/max amount.
- **Clean, flat schema**: one record per award with recipient, UEI, amount, agency and sub-agency, NAICS/PSC, place of performance, dates and a link to the USAspending page.
- **Optional competition details**: extent of competition, set-aside type, number of offers received, parent contract, recipient business categories (small business, veteran-owned, and so on) and the recipient's parent company.
- **Contracts and IDVs** (IDIQ, GWAC, BPA and other vehicles).

### Example uses

- A small business watches new awards in its NAICS code and home state.
- A subcontractor spots primes that just won large awards in a target agency.
- An analyst tracks competitors by name or UEI.
- An AI agent asks "which new awards over $1M in cybersecurity did civilian agencies make this week?" through the Apify MCP server or the API.

### Quick start

Run with the defaults to see 25 recent awards. For a daily feed, create a Schedule with `mode: sinceLastRun`, your filters, a higher `maxItems`, and a unique `stateKey`.

### Input (main fields)

| Field | Meaning |
|---|---|
| `mode` | `window` (default: everything in the last N days) or `sinceLastRun` (only new awards; **set this for daily schedules**) |
| `lookbackDays` | Window length (first-run window in sinceLastRun mode), default 7 |
| `awardTypes` | `contracts` and/or `idvs` |
| `naicsCodes`, `pscCodes`, `keywords` | What was bought |
| `placeOfPerformanceStates`, `awardingAgencies` | Where and by whom |
| `setAsideCodes` | e.g. `SBA`, `8A`, `HZC`, `SDVOSBC`, `WOSB`, `NONE` |
| `recipientSearch` | Names or UEIs to watch |
| `minAmount`, `maxAmount` | USD |
| `includeDetails` | Adds the competition and set-aside block (extra charge per award) |
| `maxItems` | Hard cap per run (also caps your spend). Default 25 so a first test run is quick and cheap; raise it for production |
| `stateKey` | Use one key per saved search so each keeps its own history |

### Output (example, trimmed from a real record)

```json
{
  "awardId": "6982AF27P000001",
  "awardUrl": "https://www.usaspending.gov/award/CONT_AWD_6982AF27P000001_6925_-NONE-_-NONE-",
  "baseObligationDate": "2026-10-28",
  "recipientName": "GCS LLC",
  "recipientUei": "JJXLTLEU5UN5",
  "amountUsd": 956200,
  "description": "CO NP BLCA 10(1) SOUTH RIM DRIVE IMPROVEMENT GUARDRAIL REPLACEMENT INSTALLATION",
  "awardType": "PURCHASE ORDER",
  "awardingAgency": "Department of Transportation",
  "naicsCode": "237310",
  "pscCode": "Y1LB",
  "placeOfPerformance": {
    "city": "MONTROSE",
    "state": "CO",
    "county": "MONTROSE",
    "zip5": "81401",
    "country": "USA"
  },
  "details": {
    "extentCompeted": "COMPETED UNDER SAP",
    "setAside": "SMALL BUSINESS SET ASIDE - TOTAL",
    "numberOfOffersReceived": 7,
    "recipientBusinessCategories": [
      "Small Business",
      "Veteran Owned Business"
    ]
  }
}
```

Every run also writes a short summary (window scanned, counts, why it stopped) to the `OUTPUT` record.

### Data source, licensing and limits

- Source: the public USAspending.gov API, which needs no API key. USAspending states its data is open to copy, adapt and redistribute ([about page](https://www.usaspending.gov/about)).
- The Actor sends a descriptive User-Agent and spaces requests about 0.4 seconds apart, well inside the published limit of 1,000 requests per 300 seconds.
- USAspending posts awards with a delay of a day or more. The Actor re-scans a 2-day overlap so late postings are not missed.
- Only entity-level fields are emitted. Street addresses are not included, and records that USAspending redacts for privacy come back without a recipient name.
- This is not an official government service and is not affiliated with USAspending.gov or the US Treasury. Amounts are as reported by agencies and can change as contracts are modified.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `award-record` | $0.004 | per contract award delivered |
| `award-enriched` | $0.006 | extra per award enriched with competition and set-aside details (only when `includeDetails` is on) |

A default test run (25 awards) costs about $0.105. A daily NAICS + state schedule with ~10 new awards/day costs about $0.045/day. `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached, so you are never charged for more than you set. No separate platform-usage charges: compute is included in the event prices.

### Support

Open an issue in the Issues tab. Data fields follow the USAspending API; if USAspending changes its API, expect a fix within a few days.

### FAQ

**Do I need a SAM.gov or USAspending API key?** No. The USAspending.gov API is public and keyless.

**How fresh is the data?** Agencies report awards to FPDS, which feeds USAspending.gov, usually within a few days of signature. The window is based on each award's base action date (new awards only). DoD contract data is published with a 90-day delay by policy, so for DoD use a longer `lookbackDays`.

**How do I track a competitor?** Put its name or UEI in `recipientSearch` and schedule the Actor daily with `mode: sinceLastRun`.

**Can I export to Google Sheets, Slack or a CRM?** Yes, use Apify integrations on the dataset, or call the Actor from Make, Zapier, n8n or the API.

# Actor input Schema

## `mode` (type: `string`):

window (default): all matching awards from the last N days, no saved state. sinceLastRun: only awards not delivered before for this State key; use this for daily schedules.

## `lookbackDays` (type: `integer`):

How far back to look on the first run (or in 'window' mode). USAspending posts awards with a delay of a day or more, so 3 is a safe default.

## `awardTypes` (type: `array`):

Contracts (definitive contracts, delivery orders, purchase orders) and/or IDVs (indefinite-delivery vehicles such as IDIQs and GWACs).

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

Match award descriptions (any of). Example: cybersecurity, janitorial, drone.

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

2-6 digit NAICS prefixes, e.g. 541512 (computer systems design) or 23 (construction).

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

Product/Service codes, e.g. D302, R425, 6515.

## `placeOfPerformanceStates` (type: `array`):

Two-letter state codes, e.g. CO, TX.

## `awardingAgencies` (type: `array`):

Exact agency names as shown on USAspending, e.g. 'Department of Defense', 'Department of Veterans Affairs'.

## `setAsideCodes` (type: `array`):

FPDS set-aside codes, e.g. SBA (small business), 8A, HZC (HUBZone), SDVOSBC (service-disabled veteran-owned), WOSB, NONE (no set-aside).

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

Only awards whose recipient name or UEI matches any of these. Use it to watch competitors or prime contractors.

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

Only awards with a current value at or above this amount, in USD.

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

Only awards with a current value at or below this amount, in USD.

## `includeDetails` (type: `boolean`):

Adds extent of competition, set-aside type, number of offers, parent contract, recipient business categories and parent company. One extra paid event and one extra API call per award.

## `maxDetails` (type: `integer`):

Safety cap on how many awards get the extra details lookup in one run.

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

Hard cap on delivered records (largest awards first). Also bounds your spend.

## `stateKey` (type: `string`):

Name for this feed's 'already delivered' memory. Use a different key per saved search so each keeps its own history.

## Actor input object example

```json
{
  "mode": "window",
  "lookbackDays": 7,
  "awardTypes": [
    "contracts"
  ],
  "keywords": [],
  "includeDetails": false,
  "maxDetails": 200,
  "maxItems": 25,
  "stateKey": "default"
}
```

# Actor output Schema

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

One record per award, newest first obligations, largest amounts first.

## `summary` (type: `string`):

Window scanned, counts, and why the run stopped.

# 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": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("moment-data/federal-contract-awards-feed").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": [] }

# Run the Actor and wait for it to finish
run = client.actor("moment-data/federal-contract-awards-feed").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": []
}' |
apify call moment-data/federal-contract-awards-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moment-data/federal-contract-awards-feed"
        }
    }
}
```

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/rjaZeKPnbxmBGa1zQ/builds/JOazge0wcVK0xIqPX/openapi.json