# Government Contract Award Monitor Federal Grant Winners (`mambalabs/public-award-monitor`) Actor

Finds the companies that won US federal contracts, US federal grants, NIH SBIR awards, or UK public contracts in the last N days. Returns one row per winning company with award count, total value, awarding body, award date, and a resolved company domain. Built for Clay and outbound.

- **URL**: https://apify.com/mambalabs/public-award-monitor.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 award winners

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### 🏛️ What can Government Contract Award Monitor do?

Give it a **register** and a **time window**. It returns **the companies that won public work in that window**, one flat row per winning company, with award count, total value, awarding body, award date, and a resolved company domain.

| 📦 What you get | ⚙️ Features and integrations |
|---|---|
| 🏢 **One row per winning company**, not one per award<br>💰 **Award count, total value and largest award** inside your window<br>🌐 **Resolved company domain**, so the row is usable without another enrichment step<br>🏛️ **Awarding body, award date and a deep link** to the source record | 🇺🇸 **US federal contracts and grants** from USASpending<br>🧬 **NIH SBIR and STTR** awards, filtered to funded startups<br>🇬🇧 **UK public contracts** from Contracts Finder and Find a Tender<br>🧊 **Clay ready** flat `snake_case` output, no nested JSON<br>⬇️ **Export** to JSON, CSV, Excel, HTML or XML |

Built for outbound operators selling into companies that just landed government or research money, and for anyone building a govcon partner or subcontractor list, because the winner list is the qualified supplier list.

> 🚫 **This is not a tender feed and not a procurement pipeline tool.**
> It does not tell you what is open to bid on. It reports awards that have **already been made** and names the company that won. If you want opportunities to bid on, you want Grants.gov or SAM.gov, and this actor deliberately does not cover them.

### 🎯 Why use Government Contract Award Monitor?

| What you are trying to do | The field that does it |
|---|---|
| Open with the win | `latest_award_title`, `latest_awarding_body`, `latest_award_date` |
| Size the opportunity | `total_award_value`, `largest_award_value`, `award_count_in_window` |
| Get the company into Clay | `recipient_domain`, `recipient_name`, `recipient_name_normalized` |
| Match against your CRM | `recipient_register_id` (UEI in the US, Companies House number in the UK) |
| Filter out the public sector | `recipient_type`, plus the `exclude_government_recipients` input |
| Territory routing | `recipient_country`, `recipient_state_or_region`, `recipient_city` |
| Cite the source | `latest_award_url` |

#### 📊 One row per company, because one company can hold most of the window

In the top 15 US federal awards for one week of July 2026, a **single recipient held 12 of the 15 rows**. A per-award feed bills you twelve times for one company and buries the long tail where the real signal is.

This actor groups awards by winner first, then sorts by total award value. Grouping is on the register's own identifier when it publishes one and on the normalized legal name when it does not, so two spellings of one UEI collapse into one company and two different companies with similar names do not.

It deliberately does **not** roll up to parent company. USASpending exposes a parent UEI, and rolling an operating company into its conglomerate would replace a specific signal with a useless one.

### 📋 What data can Government Contract Award Monitor extract?

**29 fields** per row. The ones you will actually use:

| Field | What it holds |
|---|---|
| `recipient_name` | Winner's legal name exactly as the register publishes it |
| `recipient_domain` | Resolved website, or `null` |
| `domain_status` | `resolved`, `low_confidence`, `not_found`, `not_attempted`, `search_failed` |
| `domain_confidence` | 0 to 100 |
| `recipient_register_id` | UEI on the US registers, Companies House number on the UK ones when published |
| `recipient_type` | `company`, `government`, `education`, `nonprofit`, `individual`, `joint_venture`, `unknown` |
| `award_count_in_window` | How many awards this winner took inside your window |
| `total_award_value` | Sum of those awards, in `award_currency` |
| `largest_award_value` | The biggest single one |
| `latest_award_date` | Date of the most recent award in the window |
| `latest_award_title` | What it was for |
| `latest_awarding_body` | Agency, department or council that made it |
| `latest_award_url` | Deep link to the source record |
| `fetch_status` | `ok`, `no_results`, `register_error`, `register_partial` |
| `is_summary_row` | `true` only on the fallback row a run pushes when it finds nothing |

> ⚠️ **`search_failed` and `not_found` mean opposite things, and the difference decides whether you go look manually.**
> `not_found` means the search ran and nothing resembled the company. `search_failed` means the search itself was refused, so the actor **never got to look**. A `null` domain on a `search_failed` row is not evidence the company has no website. `not_attempted` means you turned `resolve_domains` off. These are never collapsed into one null.

### 🔍 How to find companies that just won government contracts

1. Pick your `register`. Start with `us_federal_contracts`.
2. Set `window_days`. Use `7` for a weekly cadence. Do not use `1` on the US registers, because US federal data lags about two days.
3. Set `min_award_value` to the smallest deal worth your time, in the register's own currency.
4. Set `max_entities` to cap what you pay for. Winners come back sorted by total award value, so the cap keeps the biggest.
5. Leave `resolve_domains` on unless you already have domains.
6. Run it, then read `domain_status` before you trust `recipient_domain`.

#### 🧊 How to use it in Clay

Every numeric input is typed as a string, because Clay sends all inputs as strings. Output is one flat row per company in `snake_case` with no nested JSON, so it maps straight onto a Clay table without a transformation step.

Run it as a scheduled source, map `recipient_domain` into your company column, and use `domain_status` as a filter so `search_failed` rows route to a manual check instead of being written off.

#### ⚡ How to run it cheap

Set `resolve_domains` to `false`. The domain lookup is about 98 percent of the run's wall clock, so turning it off makes the run roughly 20 times faster. Rows come back with `recipient_domain: null` and `domain_status: "not_attempted"`. Use that mode when you already hold domains and only want the award signal.

### 💵 How much does it cost to monitor contract awards?

You pay per **winning company returned**.

| Plan | Price per company |
|---|---|
| Free | $0.005 |
| Bronze | $0.00475 |
| Silver | $0.0045 |
| Gold | $0.00425 |

A 200 company window costs under $1.00 on the Free tier.

> 💳 **A row with no company in it is never billed.**
> When your window genuinely holds no winners, or a register fails, the actor returns exactly one summary row with `is_summary_row: true` and charges **zero** result events. You still pay the standard Actor start event, which is $0.00005. Truncation is never silent either: if your window holds more winners than `max_entities`, the run log says exactly how many were dropped.

### ⚙️ Input

Full options are on the Input tab. The ones worth explaining:

| Field | Default | What it does |
|---|---|---|
| `register` | `us_federal_contracts` | `us_federal_contracts`, `us_federal_grants`, `us_nih_sbir`, `uk_contracts_finder`, `uk_find_a_tender` |
| `window_days` | `7` | Days back from today, 1 to 90 |
| `min_award_value` | `100000` | Drops awards below this, in the register's own currency. `0` keeps everything |
| `max_entities` | `100` | Hard cap on billed rows, 1 to 1000 |
| `exclude_government_recipients` | `true` | Drops winners that are themselves government, universities or public authorities |
| `resolve_domains` | `true` | Looks up each winner's website |
| `domain_confidence_floor` | `standard` | `strict`, `standard` or `loose` |

Leave `exclude_government_recipients` on for the grant registers. With it off, a recent 7 day US federal grant window returned 38 universities and 17 government bodies against 7 companies.

### 📤 Output

Export to **JSON, CSV, Excel, HTML or XML**, or pull it straight from the API.

```json
{
  "recipient_name": "TRIWEST HEALTHCARE ALLIANCE CORP",
  "recipient_name_normalized": "TRIWEST HEALTHCARE ALLIANCE",
  "recipient_domain": "triwest.com",
  "domain_status": "resolved",
  "domain_confidence": 50,
  "recipient_register_id": "J7M9HPTGJ1S9",
  "recipient_register_id_scheme": "UEI",
  "recipient_country": "US",
  "recipient_state_or_region": "AZ",
  "recipient_city": "Phoenix",
  "recipient_type": "company",
  "award_count_in_window": 1,
  "total_award_value": 983897123.99,
  "largest_award_value": 983897123.99,
  "award_currency": "USD",
  "latest_award_date": "2026-08-03",
  "latest_award_id": "36C10G26K0293",
  "latest_award_title": "EXPRESS REPORT: JUNE 2026",
  "latest_awarding_body": "Department of Veterans Affairs",
  "latest_award_url": "https://www.usaspending.gov/award/CONT_AWD_36C10G26K0293_3600_36C10G19D0038_3600",
  "award_type": "contract",
  "register": "us_federal_contracts",
  "register_label": "USASpending (US federal contracts)",
  "window_start": "2026-08-03",
  "window_end": "2026-08-10",
  "fetch_status": "ok",
  "fetch_error": null,
  "is_summary_row": false,
  "run_date": "2026-08-10T06:48:48.382Z"
}
```

### 💡 Tips

- **Run it weekly, not daily.** US federal data lags about two days, so a daily job re-reads mostly the same awards.
- **`us_nih_sbir` is the cleanest startup feed here.** Filtered to SBIR and STTR activity codes, a five week window returned 268 awards and the recipients are real companies with a UEI. Unfiltered, the same window held 12,155 awards dominated by universities.
- **Set `domain_confidence_floor` to `strict`** if a wrong domain costs you more than a missing one. It requires both a top result and a name match.
- **Use `recipient_register_id` to dedupe against your CRM.** It is stable, unlike a legal name.
- **A `joint_venture` row with a null domain is a correct answer.** Joint ventures win a lot of federal work and do not have websites.

### ⚠️ Known limits

**Roughly half of winners get a domain, and about one in five of those is wrong.** Platform measurement on 2026-08-10 resolved **11 of 20** winners across two runs. On a 13 target probe, precision at the default floor was about 78 percent. Always read `domain_status` and `domain_confidence` before using `recipient_domain`.

**Domain resolution runs through Brave, because DuckDuckGo refuses this traffic.** Measured from Apify infrastructure on 2026-08-10, DuckDuckGo refused **12 of 12** queries with an anti-bot challenge, and Brave answered about half. When both refuse, the row says `search_failed` rather than pretending the company has no website. Expect the domain column to be the least reliable column in the output.

**Award registers name the legal entity, not the brand.** A company that files as INTERNATIONAL BUSINESS MACHINES CORPORATION and trades as IBM will often come back with no domain, because the match works on name similarity. Large companies whose legal name differs from their brand are the most likely to return null.

**US federal data lags about two days.** Awards dated two days back are loaded; yesterday's usually are not. Do not use a one day window on the US registers.

**UK award dates can predate your window.** Both UK registers filter on when the notice was published, and a notice published this week can describe an award decided months earlier. On a recent 7 day window, 32 percent of Contracts Finder award dates fell inside the window. `latest_award_date` is the decision date as published, so check it rather than assuming it sits in your window.

**UK winner identifiers are patchy.** Measured 2026-08-10: 39 percent of Contracts Finder award suppliers and 25 percent of Find a Tender suppliers carry a real Companies House number. The rest carry only a name and an internal register row number, which is not published because it is not a lookup key for anything.

**The US and UK registers do not publish the same terms.** Both UK registers carry an explicit Open Government Licence v3.0 inline with the data, naming commercial use subject to attribution. **USASpending and NIH RePORTER publish no license statement at all**, which is not the same as publishing a permissive one. If you plan to resell US federal award data at scale, take your own advice on it.

**EU TED is not covered.** TED returns the winner's name on only about 10 percent of award notices, and getting the rest means one extra request per notice against thousands of notices per week. It will ship as its own mode rather than half working.

**A company missing from the output has not been checked and cleared.** It simply did not win in that register in that window. Absence is not evidence about any individual company.

### ❓ FAQ

**Does this show contracts I can bid on?**
No. It shows awards already made and who won them. Opportunity feeds are a different product, and Grants.gov and SAM.gov are deliberately not covered.

**Why is `recipient_domain` empty on a row that clearly has a website?**
Check `domain_status`. `search_failed` means the search was refused and never ran. `low_confidence` means a candidate was found and was not good enough to publish. Lower `domain_confidence_floor` to `loose` if you would rather verify a guess than get a null.

**Can I look up one company's awards instead of a whole window?**
Not in this version. This actor takes a window and returns companies. A company in, awards out mode is planned.

**Why are the award values so large on some rows?**
`total_award_value` is the full published award value, which on federal contracts can be a multi year ceiling rather than money already spent.

**Do summary rows cost me anything?**
No. Rows with `is_summary_row: true` carry no company and fire no billable result event.

### 🧩 Want other GTM data?

Mamba Labs builds custom actors for B2B go-to-market teams. The public versions
of that work live here on the Store, so our users get the same tooling we build
under contract.

| | |
|---|---|
| 🧑‍💼 [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) | 🧱 [Tech Stack Detector](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) |
| 📡 [B2B Buying Signals Aggregator](https://apify.com/mambalabs/b2b-buying-signals-hiring-tech-stack-intent-for-clay) | 🔑 [Job Board Keyword Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) |
| 🔗 [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) | 🎯 [ICP Fit Scorer](https://apify.com/mambalabs/icp-account-lead-scoring-fit-scorer-0-100-for-clay) |
| 📋 [Job Posting Monitor](https://apify.com/mambalabs/gtm-job-discovery) | 📬 [Domain Deliverability Checker](https://apify.com/mambalabs/domain-deliverability-checker) |
| 🏢 [Company Firmographic Enricher](https://apify.com/mambalabs/company-firmographic-enricher) | 🌐 [Company Social Presence Mapper](https://apify.com/mambalabs/company-social-presence-mapper) |
| 🪪 [Company Identity Resolver](https://apify.com/mambalabs/company-identity-resolver) | 💰 [Funding and Press Signal Scanner](https://apify.com/mambalabs/funding-press-signal-scanner) |
| 🔄 [Company Change-Event Feed](https://apify.com/mambalabs/company-change-event-feed) | 👤 [People Finder and Email Verifier](https://apify.com/mambalabs/people-finder) |
| 🚀 [Prospect Engine](https://apify.com/mambalabs/b2b-prospect-engine) | 🤖 [AI Tooling Detector](https://apify.com/mambalabs/ai-tooling-detector) |
| 📮 [Outbound Stack Detector](https://apify.com/mambalabs/outbound-infrastructure-fingerprint) | 📝 [Publishing Frequency Tracker](https://apify.com/mambalabs/blog-publishing-frequency) |
| ✉️ [Work Email Waterfall Finder](https://apify.com/mambalabs/email-waterfall-orchestrator) | ⏩ [Sequencer Lead Push](https://apify.com/mambalabs/clay-to-instantly-smartlead-push) |
| 🏅 [Workplace Program Detector](https://apify.com/mambalabs/workplace-program-detector) | 👥 [Team Page People Extractor](https://apify.com/mambalabs/team-page-people-extractor) |
| 🧭 [Company Discovery List Builder](https://apify.com/mambalabs/company-discovery-list-builder) |  |

> Every actor in the suite takes a domain or a company and returns one flat row,
> so they stack in the same Clay table without reshaping anything.

> 🛠️ **Need something custom built for you or your team?** Tell us what you are
> trying to find and we will build it. [Talk to Mamba Labs](https://mambabuilt.com/contact).

### 🛟 Support

Found a bug or want a register added? Open an issue on the Actor's Issues tab.

> **Sourcing and legal.** All award data comes from public government registers: USASpending, NIH RePORTER, UK Contracts Finder and UK Find a Tender. The two UK registers publish under the Open Government Licence v3.0. The two US registers publish no license statement. This actor returns information about legal entities and does not collect personal data; the one case where a person can appear is a sole trader trading as a business, which is labeled `individual` so you can filter it. Award registers describe what a public body published, not an assessment of any company.

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

## `register` (type: `string`):

Which award register to read. US federal contracts and grants come from USASpending, NIH SBIR and STTR from NIH RePORTER, and the two UK registers from Contracts Finder and Find a Tender.

## `window_days` (type: `string`):

How many days back from today to read awards for. 1 to 90. US federal data lags about two days, so do not use a one day window on the US registers.

## `min_award_value` (type: `string`):

Drops awards below this amount in the register's own currency. Set to 0 to keep everything.

## `max_entities` (type: `string`):

Hard cap on billed rows. 1 to 1000. Winners are sorted by total award value, and the run log says how many were dropped.

## `exclude_government_recipients` (type: `boolean`):

Drops winners that are themselves government, universities, or public authorities. Leave this on for the grant registers or you get state departments of education instead of companies.

## `resolve_domains` (type: `boolean`):

Looks up each winner's website. Turning it off makes the run roughly 20x faster and returns recipient\_domain as null with domain\_status not\_attempted.

## `domain_confidence_floor` (type: `string`):

How sure the actor has to be before it gives you a domain. Strict returns fewer domains and almost no wrong ones. Loose returns the most domains and about a third of them are wrong.

## Actor input object example

```json
{
  "register": "us_federal_contracts",
  "window_days": "7",
  "min_award_value": "250000",
  "max_entities": "10",
  "exclude_government_recipients": true,
  "resolve_domains": true,
  "domain_confidence_floor": "standard"
}
```

# 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 = {
    "register": "us_federal_contracts",
    "window_days": "7",
    "min_award_value": "250000",
    "max_entities": "10",
    "exclude_government_recipients": true,
    "resolve_domains": true,
    "domain_confidence_floor": "standard"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/public-award-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 = {
    "register": "us_federal_contracts",
    "window_days": "7",
    "min_award_value": "250000",
    "max_entities": "10",
    "exclude_government_recipients": True,
    "resolve_domains": True,
    "domain_confidence_floor": "standard",
}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/public-award-monitor").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 '{
  "register": "us_federal_contracts",
  "window_days": "7",
  "min_award_value": "250000",
  "max_entities": "10",
  "exclude_government_recipients": true,
  "resolve_domains": true,
  "domain_confidence_floor": "standard"
}' |
apify call mambalabs/public-award-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mambalabs/public-award-monitor"
        }
    }
}

```

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/zhEtllASykOcx9hJ8/builds/rbSUCQ2pluYJgqskr/openapi.json