# US Government Contract Awards Monitor - Federal Win Signals (`datasignalslab/gov-contract-awards-monitor`) Actor

US government contract awards monitor: recent federal wins per company, agency concentration and momentum, scored. Pay per company.

- **URL**: https://apify.com/datasignalslab/gov-contract-awards-monitor.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 company analyzeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## US Government Contract Awards Monitor: Federal Wins, Momentum and Agency Concentration

**Turn raw federal procurement data into a clean government contracts signal: recent wins per company, total award momentum, agency concentration and the largest new awards, scored and ranked.** Give one or more company or recipient names and this Actor pulls their recent US federal contract awards from the official USAspending.gov API. Instead of a flat list of award rows, you get a per-company view built for research: how much new federal money a company is winning, which agency is buying, and which fresh wins are the biggest. It is alternative data for traders, quants, and competitive intelligence teams who treat federal revenue as an early demand signal.

### Why this is different

Several scrapers return raw USAspending award rows. This Actor is not one of them. It computes a signal layer on top of the same official data so you do not have to.

- **Scored momentum, not a raw dump.** Each award gets an impact score from 0 to 100 based on size plus recency, and awards are ranked so the largest, freshest federal wins surface first.
- **Recent wins only.** The query uses the USAspending `new_awards_only` date type, so you see contracts newly signed inside your look-back window. Old megacontracts that merely had a recent modification are excluded.
- **Momentum per company.** Every company returns a total recent award value and an award count, plus a count of high-value ($10M and above) wins.
- **Agency concentration.** The Actor aggregates award value by awarding agency and reports the single biggest buyer per company, so you can see who is funding the revenue.
- **Verifiable.** Every award carries a direct link to its USAspending.gov page, so any number traces back to the official source.

### Who it's for

- **Traders, quants and portfolio managers** who treat federal contract revenue as an early demand signal and want a ready-made government contracts feed for screening and research rather than a manual USAspending search.
- **Competitive intelligence and business development teams** who track who is winning in their market, from which agency, and how recent and large those defense contracts and civilian awards are.
- **Fintech and research apps** that want to drop structured contract-win data into a product, dashboard, or model without maintaining a USAspending integration.

### Use cases

- **Federal-revenue screening.** Run a watchlist of contractors and rank them by recent award momentum to spot which names are accelerating.
- **Defense and govcon coverage.** Monitor defense contractors for large new Department of Defense task orders and see how concentrated their wins are in one agency.
- **Event and catalyst research.** Flag a large, recent federal win on a company you follow and trace it to the exact award before it reaches headlines.
- **Business development intelligence.** Track competitors and partners to see which agencies are awarding work in your space and at what size.
- **Watchlist monitoring.** Schedule recurring runs so a new high-impact award on any tracked company is captured automatically.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `companies` | array | yes | - | One or more company or recipient names (for example Palantir, Lockheed Martin, Booz Allen). Each is scanned for recent federal contract awards. |
| `sinceDays` | integer | no | 365 | Look-back window in days. Only contracts newly awarded within this many days are counted (7 to 1095). |
| `maxAwards` | integer | no | 25 | How many of the company's largest recent awards to return and rank per company (1 to 100). |
| `minImpact` | integer | no | 0 | Only return awards at or above this impact score, 0 to 100. For example 85 keeps roughly $100M and larger recent wins. 0 returns all. |

### Output

The Actor pushes one item per company: the query, total recent award value, award count, a high-value ($10M and above) count, the top agency by value, and a ranked list of awards. Every award includes the recipient, amount, awarding agency and sub-agency, start date, description, award ID and type, the impact score, a short catalyst string, and a direct USAspending.gov URL.

```json
{
  "type": "gov_contracts",
  "query": "Palantir",
  "total_recent_value": 744000000.0,
  "award_count": 12,
  "high_value_count": 5,
  "top_agency": "Department of Defense",
  "awards": [
    {
      "recipient": "PALANTIR USG, INC.",
      "amount": 293000000.0,
      "agency": "Department of Defense",
      "sub_agency": "Department of the Army",
      "start_date": "2026-03-14",
      "description": "DATA PLATFORM AND ANALYTICS SERVICES",
      "award_id": "W912CG26F0001",
      "award_type": "DEFINITIVE CONTRACT",
      "impact": 95,
      "catalyst": "$293,000,000 contract from Department of Defense",
      "url": "https://www.usaspending.gov/award/CONT_AWD_W912CG26F0001"
    }
  ]
}
````

Amounts and example values above illustrate the schema. Live values come straight from USAspending.gov at run time.

### How the score works

The impact score is transparent and computed only from award size and recency.

- **Size band sets the base.** $1B and above scores 95. $100M to $1B scores 85. $10M to $100M scores 70. $1M to $10M scores 55. Below $1M scores 40.
- **Recency adds a bonus.** If the award start date is within the last 90 days, add 10; within the last 365 days, add 5. The total is capped at 100.

Awards are then sorted by impact, highest first, so the largest and most recent government contracts rank at the top. There is no hidden input and no model: the same award always produces the same score.

### Use with AI agents and automation

This Actor returns clean JSON on demand or on a schedule, which makes it easy to wire into agents and automation.

- **AI agents and frameworks.** Call it from LangChain or LlamaIndex as a tool, or expose it through the Apify MCP server so an assistant such as Claude, ChatGPT, or Cursor can run it and read the results directly.
- **No-code automation.** Route output through Zapier or Make to a spreadsheet, database, or alert channel.
- **Webhooks.** Fire a webhook on run completion to push fresh contract-win data into your own systems.
- **On demand or scheduled.** Run it ad hoc, or schedule recurring runs to keep a watchlist monitored.

### Pricing

This Actor uses pay-per-event pricing: one charge per company analyzed, billed as the `company-analyzed` event. Scanning a 10-company watchlist is 10 charges. There is no subscription and no monthly minimum, so you pay only for the companies you actually scan.

### Data source and compliance

All data comes from the official **USAspending.gov API** operated by the US Treasury under the DATA Act. It is public federal spending data, served over REST and JSON with no API key required. The Actor reads award records about organizations and federal agencies, not individuals: it does not collect or process personal data, and every award links back to its official USAspending.gov page so the source is fully auditable.

### FAQ

**Where does the data come from?** USAspending.gov, the official US Treasury source for federal spending mandated by the DATA Act. The Actor uses the public API with no key required.

**What counts as a recent win?** The query uses the `new_awards_only` date type, so only contracts newly signed inside your `sinceDays` window are returned. Old contracts with a recent modification are excluded.

**Does a contract win guarantee revenue?** No. It signals awarded federal money; recognized revenue depends on execution and timing, so treat it as a signal, not a certainty.

**How current is the data?** USAspending is updated continuously, and each run reads the latest awards available at that moment.

**Can an AI agent call this automatically?** Yes. Expose it through the Apify MCP server and an AI agent such as Claude, ChatGPT, or Cursor can invoke it on its own and read the JSON output. It also works as a LangChain or LlamaIndex tool.

**How am I charged?** Per company analyzed. One company in your input is one charge, with no subscription.

***

*Keywords: government contracts, federal contract awards, USAspending API, govcon, defense contracts, government spending data, contract win signal, federal procurement, BD intelligence, alternative data, contractor revenue signal.*

***

**Note:** Provided as data for research, screening and monitoring, not investment advice. Historical patterns do not guarantee future results.

# Actor input Schema

## `companies` (type: `array`):

One or more company / recipient names (e.g. Palantir, Lockheed Martin, Booz Allen). Each is scanned for recent federal contract awards.

## `sinceDays` (type: `integer`):

Only count contracts newly awarded within this many days (recency window).

## `maxAwards` (type: `integer`):

How many of the company's largest recent awards to return and rank.

## `minImpact` (type: `integer`):

Only return awards at or above this impact score (e.g. 85 = $100M+ recent wins). 0 = all.

## Actor input object example

```json
{
  "companies": [
    "Palantir",
    "Lockheed Martin"
  ],
  "sinceDays": 365,
  "maxAwards": 25,
  "minImpact": 0
}
```

# 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 = {
    "companies": [
        "Palantir",
        "Lockheed Martin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasignalslab/gov-contract-awards-monitor").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 = { "companies": [
        "Palantir",
        "Lockheed Martin",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datasignalslab/gov-contract-awards-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "Palantir",
    "Lockheed Martin"
  ]
}' |
apify call datasignalslab/gov-contract-awards-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datasignalslab/gov-contract-awards-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Government Contract Awards Monitor - Federal Win Signals",
        "description": "US government contract awards monitor: recent federal wins per company, agency concentration and momentum, scored. Pay per company.",
        "version": "0.1",
        "x-build-id": "AJKtJgjALVercHAh3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasignalslab~gov-contract-awards-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasignalslab-gov-contract-awards-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datasignalslab~gov-contract-awards-monitor/runs": {
            "post": {
                "operationId": "runs-sync-datasignalslab-gov-contract-awards-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datasignalslab~gov-contract-awards-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-datasignalslab-gov-contract-awards-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies (federal contractors)",
                        "type": "array",
                        "description": "One or more company / recipient names (e.g. Palantir, Lockheed Martin, Booz Allen). Each is scanned for recent federal contract awards.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceDays": {
                        "title": "Look-back window (days)",
                        "minimum": 7,
                        "maximum": 1095,
                        "type": "integer",
                        "description": "Only count contracts newly awarded within this many days (recency window).",
                        "default": 365
                    },
                    "maxAwards": {
                        "title": "Max awards per company",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many of the company's largest recent awards to return and rank.",
                        "default": 25
                    },
                    "minImpact": {
                        "title": "Minimum impact score (0-100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return awards at or above this impact score (e.g. 85 = $100M+ recent wins). 0 = all.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
