# USAspending Contract Runway & Extension Monitor (`thescrapelab/usaspending-contract-runway-monitor`) Actor

Build evidence-backed contract capture briefs from USAspending. Filter by industry, agency, incumbent and value; inspect recent modifications, separate current/potential end dates, and alert on material changes and review-window entries.

- **URL**: https://apify.com/thescrapelab/usaspending-contract-runway-monitor.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 completed contract checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## USAspending Contract Runway & Extension Monitor

Track reported federal contract end dates and the changes that affect your capture watchlist. Get incumbent organizations, current and potential performance end dates, funding facts and exact before/after changes from the official USAspending API.

### Start with a small run

1. In **Input**, choose **Find contracts by keyword or filters**, then add your keywords. Leave keywords blank to try the small software-contract demonstration, or open **Refine your search** to filter by industry, agency or company.
2. Keep **Maximum results to save** at 5 for your first run. **Maximum contracts to check** bounds attempted lookups; successful checks can be billed even when your output filters hide them. Leave **Include recent contract transactions** off for the fastest first run.
3. Click **Start**. In **Output**, open **Start here: capture brief (HTML)** for a readable summary and recommended next steps, or open **Saved contract observations** to sort and export the data.

To monitor known contracts instead, choose **Recheck contracts by ID** and paste their USAspending IDs into **Contract IDs to recheck**. For later runs, reuse the generated **Ready-to-recheck watchlist input** so comparisons retain their previous observations. The other settings are grouped into optional sections; their defaults are suitable for the first run.

### Simple introductory pricing

**$1.50 per 1,000 completed contract checks**, plus **$0.00005 per run**. Standard-run platform usage, capture briefs, alerts, snapshots and bounded transaction history are included. There is no monthly rental or feature surcharge. For example, five completed checks cost **$0.00755** and 1,000 completed checks cost **$1.50 plus the start fee for each run**. Use bounded batches for larger workloads.

One check means one successfully retrieved, normalized and stored canonical contract observation. **Unchanged checks and checks hidden by `onlyAlerts` or the horizon filter still count.** Rechecking the same contract in a new run is a new check. Failed or unavailable award lookups and duplicate aliases within a run are not billed as completed checks; the start fee still applies to an empty or failed run.

Open **All completed contract checks** in Output to see every stored observation, including quiet checks, with links to the full records. The dataset and capture brief contain only observations matching your output filters. `RUN_SUMMARY.billing` reports confirmed checks; a storage or charging failure can leave an accessible observation that was not billed.

Set **Maximum charge per run** in Apify run options to control spending. The Actor stops before another source lookup when it cannot afford another check and preserves completed output. `maxResults` limits dataset rows; use `maxAwardsToScan` to bound checks, especially with alert-only filters. A low spending limit may produce partial coverage. The introductory rate has no scheduled increase; review any future pricing notice in Apify before running.

### Capture briefs and useful monitoring

The Actor now produces a **capture review queue**, a standalone HTML brief, a CSV shortlist and incumbent rollups. Each queued contract explains why it deserves review and links to source evidence.

- **Target discovery:** Filter by NAICS industry prefix, exact top-tier awarding agency, incumbent organization and reported obligation range. Sort by value, modification date or current end date. Filters run at the source before detail retrieval.
- **Separate date contexts:** A current end in 2027 with a potential end in 2030 receives an option-context review label. A potential end inside your horizon receives a separate planning-review label. Neither establishes a future RFP or that all contractual options are exhausted.
- **Inspect real transactions:** Enable `includeTransactions` for bounded recent modification records, action descriptions and funding changes. History can be complete, sampled or unavailable; lookback totals cover only sampled records. If a later history page fails or exhausts the request budget, earlier records remain available with an explicit warning and incomplete coverage. Historical end dates are not reconstructed.
- **Reduce repeat noise:** `onlyAlerts` saves first observations (when enabled), material obligation changes, incumbent/date changes, new latest-transaction identities and entry into configurable review windows. A current end date becoming missing or being restored also alerts, without inventing an extension length. Countdown-only window entries can alert even when the source facts remain unchanged. Successful suppressed observations still update state. Alert IDs distinguish separate occurrences of a repeated change; comparison against the same prior observation keeps the ID stable.

A targeted search example:

```json
{
  "mode": "search",
  "naicsCodes": ["541512"],
  "awardingAgencies": ["Department of Veterans Affairs"],
  "minObligationUsd": 1000000,
  "activityDateType": "last_modified_date",
  "sortBy": "Last Modified Date",
  "sortOrder": "desc",
  "includeTransactions": true,
  "maxTransactionsPerAward": 5,
  "maxResults": 10,
  "maxAwardsToScan": 10,
  "maxHttpRequests": 40
}
```

No hidden keyword is added to an industry, agency or incumbent search. With no discovery filters, the default small demonstration searches for software. An activity window is still applied; it is not a complete expiry inventory.

Read the outputs **Start here: capture brief (HTML)**, **Review brief & incumbent totals (JSON)**, **Review queue spreadsheet (CSV)** and **Ready-to-recheck watchlist input** after a run. **All completed contract checks** includes the full stored observations even when output filters suppress them. A quiet run still produces follow-up input for its original watchlist, including unavailable awards. Discovery also retains successfully evaluated contracts suppressed by the horizon filter. Follow-up input preserves your horizon, first-observation setting and work limits. An empty discovery without any evaluated contracts has no watchlist artifact.

The watchlist artifact uses your named store when one was supplied. Otherwise it includes updated portable snapshots; use the newest generated input after each recheck, or use a named store for recurring monitoring. No schedule is created. `maxHttpRequests` caps all search, detail, transaction and retry calls. `maxTransactionRequestsPerAward` separately caps transaction attempts, including retries, at eight per contract by default (adjustable from one to eight). Reaching it keeps the available sample, marks history incomplete with `stopReason: "transaction_request_limit"`, and continues to the next contract. It adds no fee. Use transaction pages of ten or more for larger samples.

### Use cases

- Recheck a contract watchlist without a SAM.gov key.
- Separate a current end date from a later potential end date before prioritizing research.
- Detect observed extensions, shortened dates and changes in reported obligations or outlays.
- Export structured facts with source links, quality flags and coverage information.

Reported dates can change. An approaching date does not confirm a new solicitation or recompete. Option-date gaps do not prove that an option remains legally available. Obligations, outlays and contract ceiling values represent different financial facts.

### Inputs

Use **search** to discover a bounded set of contract awards by keyword and award-activity dates. Use **watchlist** for recurring checks of known numeric USAspending IDs or full `CONT_AWD_` identifiers.

```json
{
  "mode": "search",
  "keywords": ["software"],
  "maxResults": 20,
  "maxAwardsToScan": 50,
  "maxPages": 2,
  "horizonDays": 365
}
```

Activity dates filter the source's award activity; they do not select every contract expiring in a period. The horizon is applied after detail retrieval. `onlyWithinHorizon` saves only contracts whose current end date is between the reference date and the horizon, inclusively. Filtered contracts still count toward evaluation limits and update their snapshots.

For automatic comparison, supply `monitorStoreName` with an explicit key-value store name and reuse it on later runs. Run only one monitor at a time per store. You can also pass the previous run's `SNAPSHOTS` array as `previousSnapshots`; matching input snapshots take precedence. No schedule is created by this Actor.

`maxResults`, `maxAwardsToScan`, `maxPages` and `maxRuntimeSeconds` independently bound work. Defaults save at most five contracts, evaluate at most ten and allow two minutes, with at most 30 HTTP requests. No proxy is used. Large inputs can finish partially when a bound is reached.

### Output

Start with the HTML brief, then use the table or CSV for your shortlist:

| Output | When to use it |
|---|---|
| **Start here: capture brief (HTML)** | Read the summary, dates, funding, review reasons and recommended next actions. |
| **Saved contract observations** | Scan the default shortlist; switch views for dates and funding, changes and evidence. Export CSV, Excel or JSON from the dataset. |
| **Review queue spreadsheet (CSV)** | Download contracts that need review under the selected rules. Watch-only contracts remain in the dataset when your filters allow them. |
| **All completed contract checks** | Inspect every stored observation, including successful checks hidden from the dataset. Follow each observation link for its full record. |
| **Ready-to-recheck watchlist input** | Copy this input into a new run to check the same contracts again while retaining comparison state. |

An empty alert table can be normal: contracts may have been checked successfully without a new alert. The brief separates completed checks from saved results and explains coverage limits. A partial run does not mean every matching contract was checked.

The dataset contains one row per canonical contract matching your output filters. The JSON retains the full evidence and stable field names for integrations; table labels are designed for reading. Each row includes:

| Field | Meaning |
|---|---|
| `awardId`, `recipientName`, `recipientUei` | Contract and incumbent organization identity |
| `currentEndDate`, `potentialEndDate` | Separate reported performance dates |
| `daysToCurrentEnd`, `daysToPotentialEnd`, `optionDateGapDays` | Calendar-day calculations against `asOfDate` |
| `expiryWithinHorizon`, `expiryBucket` | Transparent current-date window labels |
| `totalObligationUsd`, `totalOutlayUsd` | Committed amounts and reported outlays, kept separate |
| `baseAndExercisedOptionsUsd`, `baseAndAllOptionsUsd` | Source contract value fields; not a revenue forecast |
| `changeType`, `changes` | Baseline, unchanged or changed facts with before/after values |
| `dateChangeType`, `currentEndDateDeltaDays` | Observed extension/shortening compared with the last successful observation |
| `dataQualityFlags`, `provenance` | Missing/inconsistent dates and source field paths |
| `sourceUrl`, `sourceApiUrl`, `observedAt` | Direct evidence links and observation time |

A shortened example from a genuine run (reported facts can change):

```json
{
  "awardId": "CONT_AWD_36C10B22N10030033_3600_VA11816D1003_3600",
  "recipientName": "GOVCIO, LLC",
  "currentEndDate": "2027-06-12",
  "potentialEndDate": "2027-06-12",
  "totalObligationUsd": 79659321.52,
  "sourceUrl": "https://www.usaspending.gov/award/CONT_AWD_36C10B22N10030033_3600_VA11816D1003_3600",
  "capture": {
    "category": "potential_end_in_window",
    "reviewPriority": "review_now",
    "recommendedNextStep": "Review acquisition planning and published notices for the reported potential end window. Confirm dates with the agency before treating this as a bid opportunity."
  }
}
```

The first observation is `baseline`. Only tracked factual changes produce `changed`; a countdown moving by one day does not. Unavailable awards are listed in `RUN_SUMMARY.failures` and are never declared removed. Missing monetary data stays null; a real zero stays zero.

The key-value outputs are `RUN_SUMMARY` (coverage, limits, requests, failures and structured health warnings) and `SNAPSHOTS` (portable comparison state). Capped or failed searches are explicitly incomplete. No private credentials, executive compensation, DUNS numbers, personal contact details or street addresses are collected in output.

### Python API integration

Use your Apify API token to run the Actor and read its dataset:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/usaspending-contract-runway-monitor").call(run_input={
    "mode": "search",
    "keywords": ["software"],
    "maxResults": 20,
    "maxAwardsToScan": 50
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["recipientName"], row["currentEndDate"], row["potentialEndDate"])
```

Source: [USAspending.gov](https://www.usaspending.gov/) and its [public API](https://api.usaspending.gov/docs/endpoints). This product is independent of the U.S. government. Source reporting can be incomplete or delayed, and reported performance dates are not procurement commitments.

### Support

Use the Actor’s Issues tab for support. Include the run ID and affected public award ID. Never include API tokens.

### Safe recurring monitoring and recovery

Cloud runs sharing a `monitorStoreName` coordinate through a server-side lease. An overlapping run fails with `MONITOR_STORE_BUSY` before collecting source records; retry after the active run finishes. Ownership is checked before shared snapshot writes and renewed during longer runs. A hard stop can leave the lease held for up to two minutes. Local processes still require one writer per store.

For a bounded watchlist, use the newest **Ready-to-recheck watchlist input** after each run. It moves attempted IDs behind unattempted IDs, so a small scan limit can progress through the whole watchlist over successive runs. Successfully resolved numeric IDs become stable canonical IDs. Failed numeric lookups retain potentially matching portable snapshots for later comparison. If ambiguous portable state exceeds the supported limit, the brief explains how to split the input and recover from the original input plus current snapshots; an invalid oversized follow-up input is not generated.

`RUN_CHECKPOINT` retains committed progress and portable snapshots. On a graceful abort or migration notice, the Actor stops source work and exports partial results with an explicit interruption status. Start a **new** run with `WATCHLIST_INPUT` to continue monitoring; if interruption occurred before any observation, reuse the original input. Restarting or resurrecting the same run preserves its prior artifacts and refuses silent replay. Dataset delivery and snapshot updates are separate operations, so exactly-once delivery and automatic scan resumption are not guaranteed. A hard kill can interrupt the last in-flight write.

When raising `maxRuntimeSeconds`, also set the Apify run timeout at least 60 seconds higher. Source input cannot extend a shorter platform timeout.

# Actor input Schema

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

Choose Find contracts to discover contracts. Choose Recheck contracts to check only the IDs entered below. Neither option creates an automatic schedule.

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

Search mode only. Add terms such as software, cybersecurity or facilities. Leave blank to use industry, agency or company filters below. With no search filters, a small software-contract demonstration is used.

## `awardIds` (type: `array`):

Recheck mode only: add at least one USAspending numeric award ID or full CONT_AWD\_ identifier. Copy these from a previous result’s awardId field. The web page’s full URL is not an ID.

## `maxResults` (type: `integer`):

Stop after saving this many contracts. Duplicate contracts are saved once. Alert and end-date filters can reduce the number saved; successful checks that do not produce a result are still billed.

## `maxAwardsToScan` (type: `integer`):

Limits attempted contract lookups, including unavailable records and duplicate ID aliases. Successful unique checks cost $1.50 per 1,000, including quiet or filtered-out checks. Failed lookups are not billed as checks. Each run also has a $0.00005 start fee.

## `includeTransactions` (type: `boolean`):

Optional. Add reported funding actions and modifications to each result and the capture brief. Uses more source requests and time, with no additional transaction fee. Leave off for the fastest first run.

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

Search mode only. Optional 2–6 digit NAICS prefixes; for example, 541512 for computer systems design. Filters at the source before contract details are checked.

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

Search mode only. Use exact top-level agency names, such as Department of Veterans Affairs. Filters at the source before contract details are checked.

## `recipientName` (type: `string`):

Search mode only. Enter one organization name to find contracts reported for that recipient, for example an incumbent or competitor.

## `minObligationUsd` (type: `number`):

Search mode only. Optional lower bound on the source’s Award Amount. Obligations are reported commitments, not the potential contract ceiling.

## `maxObligationUsd` (type: `number`):

Search mode only. Optional upper bound on the source’s Award Amount. Must be at least the minimum amount if both are set.

## `activityFrom` (type: `string`):

Search mode only. Optional YYYY-MM-DD date; defaults to one year before the run. Searches reported award activity, not contract expiration.

## `activityTo` (type: `string`):

Search mode only. Optional YYYY-MM-DD date; defaults to today in UTC. Must be on or after the activity start date.

## `activityDateType` (type: `string`):

Search mode only. Leave at USAspending default for a first run. Last modified date finds record updates. These dates describe source activity, not contract expiration.

## `sortBy` (type: `string`):

Search mode only. Controls which contracts are checked first within the search and check limits.

## `sortOrder` (type: `string`):

Search mode only. Ascending puts smaller amounts or earlier dates first; descending puts larger amounts or later dates first.

## `horizonDays` (type: `integer`):

A contract is inside this window when its reported current end date is today through this many days ahead, including the boundary. Defaults to 365 days.

## `onlyWithinHorizon` (type: `boolean`):

Optional. Filters saved results after each detail check. Non-matching successful checks still update monitoring snapshots and are billed. Review them in All completed contract checks. Search and run limits can leave coverage incomplete.

## `asOfDate` (type: `string`):

Optional YYYY-MM-DD date. Leave blank to calculate days remaining from today in UTC. Setting this date changes calculations; it does not retrieve historical source records.

## `monitorStoreName` (type: `string`):

Optional. Reuse the same unique name in later runs to compare contracts with earlier observations, for example my-contract-watchlist. Use 3–63 letters, numbers or hyphens; start with a letter or number. Run one check at a time for each name. If another run is active, retry after it finishes; a hard stop can hold the lock for up to two minutes. This saves history; it does not create a schedule.

## `onlyAlerts` (type: `boolean`):

Optional. Save first observations when enabled, material factual changes and entries into the alert windows below. Use a saved monitoring history name or previous snapshots to compare runs. Quiet successful checks still update history, are billed and remain in All completed contract checks.

## `includeFirstObservations` (type: `boolean`):

When saving only alerts, keep the initial observation as a baseline result. First seen does not mean newly awarded. Turn off for a silent initial baseline.

## `alertWindowDays` (type: `array`):

Positive, unique numbers such as \[30, 90, 180]. Alerts when current or potential end dates enter a window, including when only the countdown changes. This requires a comparable earlier observation.

## `materialObligationChangeUsd` (type: `number`):

Absolute obligation increase or decrease required for a funding alert. Defaults to $100,000. No future spending or revenue is inferred.

## `previousSnapshots` (type: `array`):

Optional alternative to saved monitoring history. Paste the full SNAPSHOTS array from an earlier run. Entries match by canonical award ID and override saved-history entries for the same IDs.

## `maxTransactionsPerAward` (type: `integer`):

Used only when recent transactions are enabled. Keep at most this many unique reported transactions for each contract. Marked as sampled when more are available.

## `transactionLookbackDays` (type: `integer`):

Used only when recent transactions are enabled. Summary counts cover sampled actions within this many days. A capped sample is not a complete total for the period.

## `transactionPageSize` (type: `integer`):

Used only when recent transactions are enabled. Fixed history page size. Smaller pages may require more requests to reach the per-contract sample limit.

## `maxTransactionRequestsPerAward` (type: `integer`):

Used only when recent transactions are enabled. Counts history request attempts, including retries. Keeps partial history and continues with other contracts when reached. Included in the existing check price.

## `pageSize` (type: `integer`):

Advanced, search mode only. Fixed page size for the whole run. Smaller pages require more search requests.

## `maxPages` (type: `integer`):

Advanced, search mode only. Stop discovery after this many pages. Contract detail checks have their own separate limit.

## `maxHttpRequests` (type: `integer`):

Hard request budget shared by search, contract details, transaction history and retries. Reaching it safely stops source work and marks the summary incomplete.

## `requestIntervalMs` (type: `integer`):

One request stream, with at least this delay between requests. Retries also respect the delay and the source’s Retry-After header.

## `maxRuntimeSeconds` (type: `integer`):

Safely stops source collection at this deadline. If you raise it, set the Apify run timeout at least 60 seconds higher. Interrupted runs retain committed checkpoints and cannot automatically replay the same run.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [],
  "maxResults": 5,
  "maxAwardsToScan": 10,
  "includeTransactions": false,
  "activityDateType": "source_default",
  "sortBy": "Award Amount",
  "sortOrder": "desc",
  "horizonDays": 365,
  "onlyWithinHorizon": false,
  "onlyAlerts": false,
  "includeFirstObservations": true,
  "alertWindowDays": [
    30,
    90,
    180
  ],
  "materialObligationChangeUsd": 100000,
  "maxTransactionsPerAward": 10,
  "transactionLookbackDays": 90,
  "transactionPageSize": 10,
  "maxTransactionRequestsPerAward": 8,
  "pageSize": 50,
  "maxPages": 2,
  "maxHttpRequests": 30,
  "requestIntervalMs": 1000,
  "maxRuntimeSeconds": 120
}
```

# Actor output Schema

## `captureBrief` (type: `string`):

Readable HTML summary with review priorities, next steps, coverage, pricing explanation and download links.

## `contracts` (type: `string`):

Saved rows selected by your output rules. Use the Start here dataset view; quiet or filtered checks can be absent from this dataset.

## `captureCsv` (type: `string`):

Contracts requiring review with dates, next steps and source links; the queue can be empty even when checks completed.

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

Check this before relying on the results: query coverage, stop reason, completed checks and failed lookups.

## `watchlistInput` (type: `string`):

Input for a new watchlist run, preserving its comparison state and prioritizing unattempted IDs. May be unavailable when no watchlist can be generated.

## `captureData` (type: `string`):

Structured review queue and organization totals for the saved observations only.

## `contractChecks` (type: `string`):

Index of full observation links. Use this when the saved dataset is empty or filtered; counts are not individual payment receipts.

## `snapshots` (type: `string`):

Portable baseline for later watchlist checks; contains completed checks even if output rules suppress the dataset row.

## `checkpoint` (type: `string`):

Preserved progress for reviewing an interrupted run before starting a new one.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/usaspending-contract-runway-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/usaspending-contract-runway-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 '{}' |
apify call thescrapelab/usaspending-contract-runway-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/usaspending-contract-runway-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/qgrlIyrbMaqyCNZGf/builds/dGbIgeQa46PwfgLrx/openapi.json