# Prime-Win Subcontract Radar: Federal Award Alerts by NAICS (`yungstentech/prime-win-subcontract-radar`) Actor

Watch the NAICS codes, states and agency you name and get freshly-awarded federal prime contracts as deduped alert rows, each with the prime's business size and a size-gated FAR 19.702 subcontracting-plan indicator, from USAspending's keyless public feed on your schedule.

- **URL**: https://apify.com/yungstentech/prime-win-subcontract-radar.md
- **Developed by:** [Paul Mikulskis](https://apify.com/yungstentech) (community)
- **Categories:** Automation, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,250.00 / 1,000 matched award alerts

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

**Prime-Win Subcontract Radar** watches the NAICS codes, place-of-performance states, and awarding agency you name and delivers freshly-awarded federal prime contracts that match your filter. It reads USAspending's keyless public feed, keeps a per-filter memory so you never see the same award twice, looks up each winning prime's business size, and flags the awards where a FAR 19.702 subcontracting plan is likely, so you know which primes to approach as a subcontractor and why.

This is a standing filter-watch, not a bulk export. You name the NAICS, states, and agency to track and it returns the newly-awarded primes that match, each with the obligated amount, the prime's business size, and a size-gated subcontracting-plan indicator.

### What does Prime-Win Subcontract Radar do?

Every run queries USAspending's public [award-search API](https://api.usaspending.gov) (`api.usaspending.gov`, keyless, public-domain FPDS-sourced data) for newly-awarded prime contracts matching your NAICS, states, agency, minimum amount, and award types, using the API's `new_awards_only` mode so you get genuinely new awards and not routine modifications of old contracts. It removes any award this filter has already delivered and returns the rest as flat dataset rows. For each delivered award it fetches the award detail to resolve the prime's business size, then computes `subcontractingPlanLikely`. An optional webhook posts the same new alerts to your endpoint after each run.

There is no login, no proxy, and no browser.

### Why use Prime-Win Subcontract Radar?

- **Find the primes who just won.** When a large prime lands a federal contract over the FAR 19.702 threshold, it typically must offer a subcontracting plan. This radar surfaces those wins on your NAICS on the next scheduled run after they publish.
- **The size gate does the qualifying for you.** FAR 19.702 exempts small-business primes, so an amount-only alert would waste your time on exempt small primes. `subcontractingPlanLikely` is TRUE only when the prime is other-than-small AND the amount clears the threshold.
- **No duplicates.** Each filter remembers what it has already delivered, so an overlapping window costs nothing and repeats nothing.
- **Bounded cost.** `maxAlertsPerRun` caps how many alerts one run can deliver, so a broad first-run catch-up cannot hit you with a surprise bill.
- **Public record.** Federal contract award data is public. The records are FPDS federal procurement data, read here from USAspending.gov, the public feed the U.S. Treasury operates.

### How to use Prime-Win Subcontract Radar

1. In the **Input** tab, list the **NAICS codes** you watch (for example `236220` for commercial and institutional building construction).
2. Optionally narrow by **Place of performance** states and an **Awarding agency**. At least one of NAICS, states, or agency is required.
3. Set a **Minimum award amount** if you want to skip smaller awards. The FAR flag is still evaluated at its own threshold, independent of this minimum.
4. Run it once to preview the matches. Set **Dry run** to true first to preview up to five rows with no PPE event charged and no filter/billing values saved; the preview rows still land in your dataset and ordinary Apify platform usage still applies.
5. Create a daily **Schedule**. Each scheduled run delivers only awards you have not seen before, so a daily cadence with the default 7-day lookback covers the multi-day publish lag plus weekends.
6. Optionally set a **Webhook URL** to receive each run's new alerts as a POST.

Give each distinct filter its own **Filter name** so its deduplication memory stays separate.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `naicsCodes` | One of these three | none | Up to 25 NAICS codes (2 to 6 digits each; a short code matches its whole sector). |
| `placeOfPerformance` | One of these three | none | Up to 15 two-letter state codes for where the work is performed. |
| `awardingAgency` | One of these three | none | A toptier awarding-agency name. |
| `minAwardAmount` | No | `750000` | Only awards obligated at or above this amount are returned. |
| `awardTypeCodes` | No | `["A","B","C","D"]` | Definitive contracts by default; you may add IDV codes. |
| `lookbackDays` | No | `7` | Days back from today (America/New_York) to query on the award date, 1 to 30. Overlap is free because delivered awards are deduplicated. |
| `maxAlertsPerRun` | No | `50` | Hard cap on alerts delivered and charged in one run, 1 to 500. Overflow redelivers next run. |
| `webhookUrl` | No | none | Optional https URL that receives new alerts as a POST. |
| `filterName` | No | `default` | Names this filter so its dedupe memory persists across runs. |
| `dryRun` | No | `false` | Preview up to 5 rows tagged dry-run. Charges no PPE event and saves no filter/billing values; named stores are still opened/read, preview rows still land in the dataset/OUTPUT, and ordinary platform usage still applies. |

A ready-to-run example (also the prefilled input):

```json
{
    "naicsCodes": ["236220"],
    "placeOfPerformance": ["TX", "IN", "IL"],
    "minAwardAmount": 900000,
    "lookbackDays": 21,
    "filterName": "default"
}
````

### Output

Each new award is one flat dataset row. You can download the dataset in JSON, HTML, CSV, or Excel.

```json
{
    "rowType": "alert",
    "awardId": "CONT_AWD_205AE926F00084_2050_2032H523A00001_2050",
    "piid": "205AE926F00084",
    "recipientName": "ACCENTURE FEDERAL SERVICES LLC",
    "obligatedAmount": 18479344.49,
    "awardingAgency": "Department of the Treasury",
    "naicsCode": "541512",
    "naicsDescription": "COMPUTER SYSTEMS DESIGN SERVICES",
    "placeOfPerformanceState": "VA",
    "lastModifiedDate": "2026-07-02",
    "recipientBusinessSize": "Not Designated a Small Business",
    "subcontractingPlanLikely": true,
    "subcontractingPlanBasis": "Obligated $18,479,344 at or above the $900,000 threshold (NAICS 541512) AND prime is Not Designated a Small Business (FAR 19.702). Indicator only; verify residual exemptions before relying on it.",
    "awardType": "C",
    "awardUrl": "https://www.usaspending.gov/award/CONT_AWD_205AE926F00084_2050_2032H523A00001_2050",
    "filterName": "default",
    "billing": "included-tier",
    "source": "https://api.usaspending.gov/api/v2/search/spending_by_award/"
}
```

A `summary` record is also written to the run's key-value store under `OUTPUT` with counts for the run: new awards, alerts delivered by tier, any rows withheld at your charge limit or the alert cap, the seen-set size, the feed's newest modified date, the feed lag in days, and how many awards flagged `subcontractingPlanLikely`.

#### Alert data fields

| Field | Meaning |
|---|---|
| `awardId` | The award's `generated_internal_id`. This is the deduplication key. |
| `piid` | The human award / contract number. |
| `recipientName` | The winning prime. |
| `obligatedAmount` | The award's current total obligation (USD). |
| `awardingAgency` | The awarding agency and sub-agency where present. |
| `naicsCode`, `naicsDescription` | The award's NAICS. |
| `placeOfPerformanceState` | Where the work is performed. |
| `lastModifiedDate` | The award's last modified date (YYYY-MM-DD). |
| `recipientBusinessSize` | The prime's size: "Not Designated a Small Business", "Small Business", or "unconfirmed" when the size lookup fails. |
| `subcontractingPlanLikely` | TRUE only when the amount clears the FAR 19.702 threshold AND the prime is other-than-small. Fails safe to FALSE when size is unconfirmed. An indicator, not legal advice (see below). |
| `subcontractingPlanBasis` | The amount, threshold, NAICS, and size behind the flag. |
| `awardType` | The resolved award type. |
| `awardUrl` | A USAspending link to verify the award. |
| `filterName`, `billing`, `source` | The filter this row belongs to, its billing tier, and the source API URL. |

### Demo dataset

The public demo dataset is at https://api.apify.com/v2/datasets/OeWhOFtf9mufhm553/items?format=json. It was generated by live run `4bYMrfBsCa5027yG0` from a clean representative NAICS 541512 federal-award filter with dry-run preview enabled, so it shows real USAspending prime-award alert rows with recipient, obligation, agency, business-size signal, FAR 19.702 flag, award URL, and source attribution without writing filter memory or billing alert events.

### Pricing

The actor is billed per event.

- **Monthly filter watch fee: 5.00 USD per filter.** Charged once per filter per calendar month on the first run that completes a fresh feed query.
- **Alert: 1.25 USD per delivered award** for the first 100 alerts a filter delivers in a month.
- **Volume alert: 0.60 USD per delivered award** beyond the first 100 in a month, once a broad NAICS returns that many matches.
- **First calendar month free of the watch fee.** The 5.00 USD watch fee is waived during your account's first calendar month; alerts still bill per alert. The free month applies once per account.

A dry run charges no PPE event and saves no filter or billing values, though its named watch and billing stores are still opened and read, its preview rows still land in the dataset and OUTPUT, and ordinary Apify platform compute, storage and egress usage still applies. A run that cannot complete its query charges nothing. When the national feed has not published a new award in more than 10 days, the watch fee is deferred until it does, so you never pay to watch a stalled pipeline. Alerts withheld because you reached your run's max-charge limit or your `maxAlertsPerRun` cap are not billed and are redelivered on the next run, with one marker row noting how many were held back and why.

How much a filter costs depends on how many awards match it. A narrow single-NAICS filter usually delivers only a few alerts a month; a broad, multi-state filter can bill more when many awards post, which is exactly why `maxAlertsPerRun` exists as a hard per-run ceiling. You start at 0 USD: nothing bills until an award is delivered.

### Publish lag

This is a fresh-award radar with a publish lag measured in days, not a real-time firehose. Federal award data reaches USAspending through FPDS with a lag that runs from a couple of days to a few weeks and varies by agency and NAICS. The `feedLagDays` field in the run summary surfaces the observed lag every run so you see it. A competitor pulling SAM.gov award notices may beat this on latency for some awards; this actor's edge is the standing per-filter memory, the size-gated flag, and the dedupe, not raw speed. No copy here claims "instant" or "real-time".

### The subcontracting-plan flag is an indicator, not legal advice

`subcontractingPlanLikely` is a prioritization signal. It is TRUE only when the award's obligated amount clears the current FAR 19.702 dollar threshold (900,000 USD generally, 2,000,000 USD for construction NAICS beginning 23) AND the winning prime is other-than-small. Small-business primes are exempt from the subcontracting-plan requirement, which is the whole point of the size gate: an amount-only flag would wrongly turn TRUE on every small-business set-aside win. When the prime's size cannot be confirmed the flag fails safe to FALSE and says so. Residual exemptions the public fields cannot always see (personal-services contracts, performance wholly outside the United States, no subcontracting possibilities) mean you should verify before relying on the flag for any specific award. It points you at the awards worth a closer look; it does not make the legal determination for you.

### Coming in the first update

A per-prime **teaming brief**: for any prime you name, a rollup of the agencies it serves, its NAICS mix, its total obligated dollars, its set-aside history, and any recorded subawards, so you can walk into a teaming conversation prepared. It is planned as the first telemetry-driven update.

### FAQ, limitations, and support

- **Is this data legal to use?** Federal contract award data is public. The records are FPDS federal procurement data, and this actor reads them from USAspending.gov's public keyless API, a site operated by the U.S. Treasury.
- **How fresh is the data?** New awards typically publish within a few days, but the FPDS-to-USAspending lag varies and can run longer. The `feedLagDays` field reports it every run.
- **Which NAICS and states are covered?** Any valid NAICS (up to 25 per filter) and any of the 50 states, DC, and territories (up to 15 per filter).
- **How reliable is the webhook?** It is best-effort alerting with retries. The dataset is the durable record. If you need to verify the caller, put a secret token in your webhook URL.
- **What happens if the feed changes shape?** The actor checks the response structure on every run and stops without charging if a field it depends on is missing, rather than delivering broken rows.

For issues or a custom variant, use the Issues tab on the actor page.

# Actor input Schema

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

NAICS codes to watch, one per line (for example 236220 for commercial and institutional building construction). 2 to 6 digits each; a shorter code matches its whole sector. Up to 25. At least one of NAICS codes, Place of performance, or Awarding agency is required.

## `placeOfPerformance` (type: `array`):

Two-letter state codes for where the work is performed, one per line (for example TX, IN, IL). Up to 15. At least one of NAICS codes, Place of performance, or Awarding agency is required.

## `awardingAgency` (type: `string`):

Optional toptier awarding-agency name to restrict the watch (for example "General Services Administration"). At least one of NAICS codes, Place of performance, or Awarding agency is required.

## `minAwardAmount` (type: `integer`):

Only awards whose current obligation is at least this many US dollars are returned. Default 750000 keeps awards teaming-relevant while still surfacing just-below-threshold awards; the FAR 19.702 flag is evaluated independently at $900,000 (general) or $2,000,000 (construction).

## `awardTypeCodes` (type: `array`):

USAspending contract award-type codes. Defaults to the definitive contracts A, B, C, D. You may add IDV codes (IDV\_A, IDV\_B, IDV\_C, IDV\_D, IDV\_E and the IDV\_B\_\* variants).

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

How many days back from today (America/New\_York) to query on the award date. The default of 7 covers the multi-day FPDS publish lag plus weekends on a daily schedule. Overlap between runs is free because already delivered awards are deduplicated per filter. The maximum of 30 is a catch-up ceiling.

## `maxAlertsPerRun` (type: `integer`):

Hard cap on the number of alerts delivered and charged in a single run. Overflow is not marked as seen and is redelivered on the next run, so a broad first-run catch-up cannot hit you with a surprise bill. Default 50.

## `webhookUrl` (type: `string`):

Optional https URL that receives a POST with the new alerts after each run. Best-effort alerting only: the dataset is the durable record. If you need to verify the caller, put a secret token in the URL yourself.

## `filterName` (type: `string`):

Names this filter within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Use different names for different filters; each named filter is billed separately.

## `dryRun` (type: `boolean`):

When true, fetch and match but return at most 5 preview rows tagged dry-run. It charges no PPE event and saves no filter or billing values, but this filter's named watch and billing key-value stores are still opened and read (and may be created empty), the preview rows are still written to your dataset and OUTPUT, and ordinary Apify platform compute, storage and egress usage still applies. Use it to sanity check your filter before scheduling.

## Actor input object example

```json
{
  "naicsCodes": [
    "236220"
  ],
  "placeOfPerformance": [
    "TX",
    "IN",
    "IL"
  ],
  "minAwardAmount": 900000,
  "awardTypeCodes": [
    "A",
    "B",
    "C",
    "D"
  ],
  "lookbackDays": 21,
  "maxAlertsPerRun": 50,
  "filterName": "default",
  "dryRun": false
}
```

# Actor output Schema

## `newAlerts` (type: `string`):

No description

## `runSummary` (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 = {
    "naicsCodes": [
        "236220"
    ],
    "placeOfPerformance": [
        "TX",
        "IN",
        "IL"
    ],
    "minAwardAmount": 900000,
    "awardTypeCodes": [
        "A",
        "B",
        "C",
        "D"
    ],
    "lookbackDays": 21,
    "maxAlertsPerRun": 50,
    "filterName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yungstentech/prime-win-subcontract-radar").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 = {
    "naicsCodes": ["236220"],
    "placeOfPerformance": [
        "TX",
        "IN",
        "IL",
    ],
    "minAwardAmount": 900000,
    "awardTypeCodes": [
        "A",
        "B",
        "C",
        "D",
    ],
    "lookbackDays": 21,
    "maxAlertsPerRun": 50,
    "filterName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("yungstentech/prime-win-subcontract-radar").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 '{
  "naicsCodes": [
    "236220"
  ],
  "placeOfPerformance": [
    "TX",
    "IN",
    "IL"
  ],
  "minAwardAmount": 900000,
  "awardTypeCodes": [
    "A",
    "B",
    "C",
    "D"
  ],
  "lookbackDays": 21,
  "maxAlertsPerRun": 50,
  "filterName": "default"
}' |
apify call yungstentech/prime-win-subcontract-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=yungstentech/prime-win-subcontract-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prime-Win Subcontract Radar: Federal Award Alerts by NAICS",
        "description": "Watch the NAICS codes, states and agency you name and get freshly-awarded federal prime contracts as deduped alert rows, each with the prime's business size and a size-gated FAR 19.702 subcontracting-plan indicator, from USAspending's keyless public feed on your schedule.",
        "version": "0.0",
        "x-build-id": "pTSfQzMABdaxCHD2G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yungstentech~prime-win-subcontract-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yungstentech-prime-win-subcontract-radar",
                "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/yungstentech~prime-win-subcontract-radar/runs": {
            "post": {
                "operationId": "runs-sync-yungstentech-prime-win-subcontract-radar",
                "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/yungstentech~prime-win-subcontract-radar/run-sync": {
            "post": {
                "operationId": "run-sync-yungstentech-prime-win-subcontract-radar",
                "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",
                "properties": {
                    "naicsCodes": {
                        "title": "NAICS codes to watch",
                        "type": "array",
                        "description": "NAICS codes to watch, one per line (for example 236220 for commercial and institutional building construction). 2 to 6 digits each; a shorter code matches its whole sector. Up to 25. At least one of NAICS codes, Place of performance, or Awarding agency is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeOfPerformance": {
                        "title": "Place of performance (states)",
                        "type": "array",
                        "description": "Two-letter state codes for where the work is performed, one per line (for example TX, IN, IL). Up to 15. At least one of NAICS codes, Place of performance, or Awarding agency is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "awardingAgency": {
                        "title": "Awarding agency (optional)",
                        "type": "string",
                        "description": "Optional toptier awarding-agency name to restrict the watch (for example \"General Services Administration\"). At least one of NAICS codes, Place of performance, or Awarding agency is required."
                    },
                    "minAwardAmount": {
                        "title": "Minimum award amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only awards whose current obligation is at least this many US dollars are returned. Default 750000 keeps awards teaming-relevant while still surfacing just-below-threshold awards; the FAR 19.702 flag is evaluated independently at $900,000 (general) or $2,000,000 (construction).",
                        "default": 750000
                    },
                    "awardTypeCodes": {
                        "title": "Award type codes",
                        "type": "array",
                        "description": "USAspending contract award-type codes. Defaults to the definitive contracts A, B, C, D. You may add IDV codes (IDV_A, IDV_B, IDV_C, IDV_D, IDV_E and the IDV_B_* variants).",
                        "default": [
                            "A",
                            "B",
                            "C",
                            "D"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lookbackDays": {
                        "title": "Lookback window (days)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many days back from today (America/New_York) to query on the award date. The default of 7 covers the multi-day FPDS publish lag plus weekends on a daily schedule. Overlap between runs is free because already delivered awards are deduplicated per filter. The maximum of 30 is a catch-up ceiling.",
                        "default": 7
                    },
                    "maxAlertsPerRun": {
                        "title": "Max alerts per run",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of alerts delivered and charged in a single run. Overflow is not marked as seen and is redelivered on the next run, so a broad first-run catch-up cannot hit you with a surprise bill. Default 50.",
                        "default": 50
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "Optional https URL that receives a POST with the new alerts after each run. Best-effort alerting only: the dataset is the durable record. If you need to verify the caller, put a secret token in the URL yourself."
                    },
                    "filterName": {
                        "title": "Filter name",
                        "type": "string",
                        "description": "Names this filter within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Use different names for different filters; each named filter is billed separately.",
                        "default": "default"
                    },
                    "dryRun": {
                        "title": "Dry run (preview, no PPE charge)",
                        "type": "boolean",
                        "description": "When true, fetch and match but return at most 5 preview rows tagged dry-run. It charges no PPE event and saves no filter or billing values, but this filter's named watch and billing key-value stores are still opened and read (and may be created empty), the preview rows are still written to your dataset and OUTPUT, and ordinary Apify platform compute, storage and egress usage still applies. Use it to sanity check your filter before scheduling.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
