# E-rate Form 470 Bid Radar: School & Library RFP Alerts (`yungstentech/erate-470-bid-radar`) Actor

Watch the states, service categories and keywords you name and get new FCC Form 470 filings (school and library RFPs) as deduped alert rows with the bid clock attached, pulled from USAC's official open-data feed on your schedule. Optional bid brief joins the applicant's Form 471 funding history.

- **URL**: https://apify.com/yungstentech/erate-470-bid-radar.md
- **Developed by:** [Paul Mikulskis](https://apify.com/yungstentech) (community)
- **Categories:** Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $900.00 / 1,000 matched 470 alert, included tiers

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

**E-rate Form 470 Bid Radar** watches the states, service categories, and keyword terms you name and delivers new FCC **Form 470** filings (the RFPs that schools, libraries, and consortia post when they seek E-rate funded services) that match your filter. It reads USAC's official open-data feed, keeps a per-filter memory so you never see the same 470 twice, computes each filing's competitive-bidding clock, and returns flat rows you can schedule, download, or pipe through the Apify API.

This is a standing filter-watch, not a bulk export. You name the states and terms to track and it returns the freshly posted 470s that match, each with the date the applicant can first award a contract, so you know what to bid on and how long the window stays open.

### What does E-rate Form 470 Bid Radar do?

Every run pulls a recent date window from USAC's public [FCC Form 470 dataset](https://opendata.usac.org/resource/jt8s-3q52.json) (`opendata.usac.org`, dataset `jt8s-3q52`, license public domain), keeps only the 470s whose state, service category, and optional keyword terms match your filter, removes any 470 this filter has already delivered, and returns the rest as dataset rows. Each row carries the applicant, the service request, the certified date, and `allowableContractDate` (the date, 28 days after certification, when the applicant may first award a contract). An optional webhook receives the same new alerts for real-time delivery.

Optionally, for any applicant you name by billed entity number (BEN), the actor builds a **bid brief**: a join of three public Form 471 datasets that shows the applicant's incumbent service providers, their committed funding history, and the applicant's Category 1 and Category 2 discount rates. That is bid intelligence: who already serves this applicant and at what discount, so you can price and position a competitive response.

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

### Why use E-rate Form 470 Bid Radar?

- **Watch the RFPs that matter to you.** Filter by state, by Category 1 (internet and WAN transport) or Category 2 (internal connections), and by keyword or manufacturer terms such as `firewall`, `Cisco`, or `cabling`.
- **Know the clock.** Every alert carries `allowableContractDate` and `bidDaysRemaining`, so you see how many days remain before the applicant can award, straight from USAC's own 28-day rule.
- **No duplicates.** Each filter remembers what it has already delivered, so an overlapping window costs nothing and repeats nothing.
- **Understand the incumbent.** A bid brief shows who currently serves an applicant and the discount they receive, drawn entirely from public Form 471 records.
- **Public record.** Form 470 and Form 471 filings are public E-rate records published by USAC.

### How to use E-rate Form 470 Bid Radar

1. In the **Input** tab, list the two-letter **States** you want to watch (for example `TX`).
2. Leave **Service categories** on both `CAT1` and `CAT2`, or narrow to one.
3. Optionally add **Keyword / manufacturer terms** to keep only 470s whose service request mentions them.
4. Run it once to preview the matches. Set **Dry run** to true first if you want a no-charge preview of up to five rows.
5. Create a daily **Schedule** for the actor. Each scheduled run delivers only 470s you have not seen before, so a daily cadence with the default 7-day lookback covers the portal's measured 2 to 4.5 day publishing lag plus weekends.
6. Optionally set a **Webhook URL** to receive each run's new alerts as a POST, and list **Bid brief BENs** to add a bid brief for named applicants.

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

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `states` | Yes | none | 1 to 15 two-letter state codes to watch. |
| `serviceCategories` | No | `["CAT1","CAT2"]` | `CAT1` (Category 1) and/or `CAT2` (Category 2). |
| `keywords` | No | none | Up to 25 terms, each 3 to 80 characters. Case and punctuation insensitive substring match on the service request line. |
| `lookbackDays` | No | `7` | Days back from today (America/New_York) to query on the certified date, 1 to 30. Overlap is free because delivered 470s are deduplicated. |
| `briefBENs` | No | none | Up to 10 billed entity numbers to build a bid brief for on this 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, charge nothing, write no filter memory. |

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

```json
{
    "states": ["TX"],
    "serviceCategories": ["CAT1", "CAT2"],
    "lookbackDays": 14,
    "filterName": "default"
}
````

### Output

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

```json
{
    "rowType": "alert",
    "applicationNumber": "260026228",
    "applicantName": "FESSENDEN-BOWDON SCHOOL DISTRICT 25",
    "billedEntityNumber": "134483",
    "contactName": "Darren Sheggerud",
    "contactEmail": "darren.sheggerud@k12.nd.us",
    "contactPhone": "701-547-3096",
    "complianceNote": null,
    "state": "ND",
    "city": "FESSENDEN",
    "serviceCategory": "Category 1",
    "serviceType": "Data Transmission and/or Internet Access",
    "serviceFunction": "Category One Network Equipment",
    "quantities": "1 Each",
    "manufacturer": null,
    "fundingYear": "2026",
    "certifiedDate": "2026-06-24",
    "allowableContractDate": "2026-07-22",
    "bidDaysRemaining": 16,
    "rfpDocumentUrls": ["https://publicdata.usac.org/EPC/Prd/Form470/260026228/134483/21409768-RFP%20Narrative.docx"],
    "matchedTerms": [],
    "filterName": "default",
    "billing": "included-tier",
    "source": "https://opendata.usac.org/resource/jt8s-3q52.json"
}
```

A **bid brief** row (delivered only for BENs you request) looks like:

```json
{
    "rowType": "bid-brief",
    "billedEntityNumber": "140475",
    "applicantName": "Prosper Indep School District",
    "incumbentSpins": [{ "spinName": "Zayo Group, LLC", "fundingYear": "2026", "commitmentUsd": 6931.2 }],
    "discountC1": "0.4",
    "discountC2": "0.4",
    "fundingYearsCovered": ["2026", "2025", "2024"],
    "sources": ["https://opendata.usac.org/resource/qdmp-ygft.json"],
    "billing": "bid-brief",
    "status": "ok"
}
```

If a BEN has no Form 471 record on file, the brief still ships with its sections empty and a note saying so, and it is delivered free of charge.

A `summary` record is also written to the run's key-value store under `OUTPUT` with counts for the run: new matches, alerts delivered by tier, bid briefs delivered, any rows withheld at your charge limit, the seen-set size, the feed's newest certified date, and the feed lag in days.

#### Alert data fields

| Field | Meaning |
|---|---|
| `applicationNumber` | The Form 470 application number. This is the deduplication key. |
| `applicantName`, `billedEntityNumber` | The applicant (school, library, or consortium) and its BEN. |
| `contactName`, `contactEmail`, `contactPhone` | The 470's public contact. Present for filings through funding year 2027; withheld for funding year 2028 and later (see Compliance below). |
| `complianceNote` | Present only when contact fields are withheld, explaining why. |
| `state`, `city` | The applicant's location. |
| `serviceCategory` | `Category 1` or `Category 2`. |
| `serviceType`, `serviceFunction`, `quantities`, `manufacturer` | The service request line, as filed. |
| `fundingYear` | The funding year, as filed. |
| `certifiedDate` | The date USAC certified the 470 (YYYY-MM-DD). |
| `allowableContractDate` | The first date the applicant may award a contract (28 days after certification). |
| `bidDaysRemaining` | `allowableContractDate` minus today. How long until the applicant can award. |
| `rfpDocumentUrls` | Links to the RFP documents and the certified form PDF, when the applicant attached them. |
| `matchedTerms` | Which of your keyword terms matched this 470. |
| `filterName`, `billing`, `source` | The filter this row belongs to, its billing tier, and the source dataset URL. |

### Demo dataset

The public demo dataset is at https://api.apify.com/v2/datasets/4ubo5msiUvLabVXh8/items?format=json. It was generated by live run `fanQVwHod9yfttRug` from a clean representative New York Category 1 Form 470 filter with dry-run preview enabled, so it shows a real USAC alert row with applicant, BEN, service request, bid clock, RFP 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: 0.90 USD per delivered 470** for the first 150 alerts a filter delivers in a month.
- **Volume alert: 0.45 USD per delivered 470** beyond the first 150 in a month, for the peak filing season when a broad, big-state filter can surface hundreds of matches.
- **Bid brief: 9.90 USD per brief** for each BEN you request, charged only when the brief returns real Form 471 history: an incumbent provider, a discount rate, or a funding year. A well-formed BEN with no Form 471 record on file is still returned with a note, free of charge.
- **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 nothing. A run that cannot complete its query charges nothing. When the feed has not refreshed in more than 7 days, the watch fee is deferred until it does, so you never pay to watch a paused portal. Alerts withheld because you reached your run's max-charge limit are not billed and are redelivered on the next run.

A quiet-season filter on one state costs a few alert charges a month. A broad, multi-state filter at the February peak can bill a few hundred dollars all in, watch fee included, because that is when the most 470s post.

### Seasonality

E-rate Form 470 filing runs on the program calendar. The heavy filing season is roughly July through March, and volume peaks in late winter, with February the busiest month. April through June is a trickle. A filter you schedule in the quiet months costs very little and is ready when volume returns.

### Tips and advanced options

- Run daily on a Schedule. The default 7-day lookback covers the portal's normal publishing lag plus weekends; overlap is free because 470s you have already received are deduplicated.
- Use the same `filterName` across scheduled runs so the dedupe memory persists. Use different `filterName` values for different filters.
- Set a per-run max-charge limit if you want a hard ceiling. If a run reaches it mid-delivery, the withheld 470s are not billed and return on the next run, with one marker row noting how many were held back.
- Use `dryRun` to check your states and keywords before scheduling.
- Add `briefBENs` for the applicants you are seriously considering, rather than every match, since each brief is billed.

### Compliance and responsible use

Form 470 and Form 471 records are public E-rate filings published by USAC. This actor delivers bid intelligence: what to bid on, the applicant's funding history, and the competitive-bidding clock.

A posted Form 470 is USAC's invitation to bid, not a marketing list. Through funding year 2027, a service provider may use a 470's public contact fields for responsive, bid-specific communication during the competitive-bidding window: questions about the procurement, requests for the RFP documents, and submission of a responsive bid. Generic business solicitation is outside that scope.

From funding year 2028 (the portal opens around July 2027 under FCC 26-30, WC Docket 21-455), all bid-related communication between a provider and an applicant must run inside USAC's competitive bidding portal. To match that rule, this actor withholds the `contactName`, `contactEmail`, and `contactPhone` fields for any filing in funding year 2028 or later and stamps a `complianceNote` in their place. The 470 still delivers as bid intelligence; only the direct contact fields are held back.

### FAQ, limitations, and support

- **Is this data legal to use?** Form 470 and Form 471 filings are public records published by USAC. This actor reads USAC's own open-data feed.
- **How fresh is the data?** USAC refreshes the feed on business days. During testing the newest certified 470 was a few days old, and a 4-day gap was measured over the July 4 holiday, so the portal pauses on federal holidays and weekends.
- **What is the delay between a 470 posting and my alert?** USAC's own publishing lag ran about 2 to 4.5 days during testing, so the default 7-day lookback catches new 470s on a daily schedule.
- **Which states are covered?** Any of the 50 states, DC, and the E-rate territories, up to 15 per filter.
- **Are the RFP documents themselves included?** The links are, when the applicant attached them. The actor returns the URLs USAC publishes, not the document contents.
- **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 feed's 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

## `states` (type: `array`):

The two-letter state codes this filter watches, one per line (for example TX, CA, NY). Required: 1 to 15 states. The radar watches only the states you name; it does not return every Form 470 in the country. The widest filter is 15 states.

## `serviceCategories` (type: `array`):

Which E-rate service categories to include: CAT1 (Category 1: internet and WAN transport) and/or CAT2 (Category 2: internal connections). Defaults to both. Only the values CAT1 and CAT2 are accepted.

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

Optional. When set, only 470s whose service-request line (service type, function, manufacturer, or form nickname) contains one of these terms are delivered. Case and punctuation insensitive substring match, for example "firewall", "Cisco", "cabling". Up to 25 terms, each 3 to 80 characters.

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

How many days back from today (America/New\_York) to query on the 470's certified date. The default of 7 covers the measured 2 to 4.5 day portal lag plus weekends on a daily schedule. Overlap between runs is free because already delivered 470s are deduplicated per filter. The maximum of 30 is a catch-up ceiling.

## `briefBENs` (type: `array`):

Optional. Billed entity numbers (BENs) to build a bid brief for on this run. A bid brief joins the applicant's public Form 471 funding history (incumbent providers, committed dollars, discount rates). Up to 10 BENs, digits only. Each bid brief is billed separately.

## `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, charge nothing and touch no filter memory. Use it to sanity check your filter before scheduling.

## Actor input object example

```json
{
  "states": [
    "TX"
  ],
  "serviceCategories": [
    "CAT1",
    "CAT2"
  ],
  "lookbackDays": 14,
  "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 = {
    "states": [
        "TX"
    ],
    "serviceCategories": [
        "CAT1",
        "CAT2"
    ],
    "lookbackDays": 14,
    "filterName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yungstentech/erate-470-bid-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 = {
    "states": ["TX"],
    "serviceCategories": [
        "CAT1",
        "CAT2",
    ],
    "lookbackDays": 14,
    "filterName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("yungstentech/erate-470-bid-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 '{
  "states": [
    "TX"
  ],
  "serviceCategories": [
    "CAT1",
    "CAT2"
  ],
  "lookbackDays": 14,
  "filterName": "default"
}' |
apify call yungstentech/erate-470-bid-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "E-rate Form 470 Bid Radar: School & Library RFP Alerts",
        "description": "Watch the states, service categories and keywords you name and get new FCC Form 470 filings (school and library RFPs) as deduped alert rows with the bid clock attached, pulled from USAC's official open-data feed on your schedule. Optional bid brief joins the applicant's Form 471 funding history.",
        "version": "0.0",
        "x-build-id": "JO3lc5ws3O9m4n3oN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yungstentech~erate-470-bid-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yungstentech-erate-470-bid-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~erate-470-bid-radar/runs": {
            "post": {
                "operationId": "runs-sync-yungstentech-erate-470-bid-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~erate-470-bid-radar/run-sync": {
            "post": {
                "operationId": "run-sync-yungstentech-erate-470-bid-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",
                "required": [
                    "states"
                ],
                "properties": {
                    "states": {
                        "title": "States to watch",
                        "minItems": 1,
                        "maxItems": 15,
                        "type": "array",
                        "description": "The two-letter state codes this filter watches, one per line (for example TX, CA, NY). Required: 1 to 15 states. The radar watches only the states you name; it does not return every Form 470 in the country. The widest filter is 15 states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "serviceCategories": {
                        "title": "Service categories",
                        "type": "array",
                        "description": "Which E-rate service categories to include: CAT1 (Category 1: internet and WAN transport) and/or CAT2 (Category 2: internal connections). Defaults to both. Only the values CAT1 and CAT2 are accepted.",
                        "default": [
                            "CAT1",
                            "CAT2"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keyword / manufacturer terms (optional)",
                        "type": "array",
                        "description": "Optional. When set, only 470s whose service-request line (service type, function, manufacturer, or form nickname) contains one of these terms are delivered. Case and punctuation insensitive substring match, for example \"firewall\", \"Cisco\", \"cabling\". Up to 25 terms, each 3 to 80 characters.",
                        "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 470's certified date. The default of 7 covers the measured 2 to 4.5 day portal lag plus weekends on a daily schedule. Overlap between runs is free because already delivered 470s are deduplicated per filter. The maximum of 30 is a catch-up ceiling.",
                        "default": 7
                    },
                    "briefBENs": {
                        "title": "Bid brief BENs (optional)",
                        "type": "array",
                        "description": "Optional. Billed entity numbers (BENs) to build a bid brief for on this run. A bid brief joins the applicant's public Form 471 funding history (incumbent providers, committed dollars, discount rates). Up to 10 BENs, digits only. Each bid brief is billed separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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 charge)",
                        "type": "boolean",
                        "description": "When true, fetch and match but return at most 5 preview rows, charge nothing and touch no filter memory. 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
