# USAspending Federal Awards & Recipient Monitor (`cliqtomedia/usaspending-federal-awards-monitor`) Actor

Track awarded US federal contracts, grants, loans and IDVs from USAspending.gov by recipient, UEI, agency, NAICS or PSC. Obligations and outlays kept separate, award links, and new/updated alerts between runs.

- **URL**: https://apify.com/cliqtomedia/usaspending-federal-awards-monitor.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (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 $2.00 / 1,000 award records

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 Federal Awards & Recipient Monitor finds US federal contracts, grants, loans and other awards in the official USAspending.gov data. Filter by recipient name or UEI, awarding agency, NAICS, PSC, keyword and dates. You get one clean row per award, with the recipient, the agencies, the obligated amount and the outlays as separate numbers, dates, codes and links to USAspending.

It is made for B2G sales and capture teams, due diligence and grant research. Save a monitor key and the next run shows only new and updated awards. No login and no API key are needed. The form example (20 Veterans Affairs IT contracts from the last 30 days) finishes in a few seconds and costs $0.042.

![US Federal Awards Monitor: agency, NAICS and date filters in, one row per federal award out with obligated amount and outlays kept apart, plus new and updated awards since the last run](https://api.apify.com/v2/key-value-stores/fj5XB23okog8O2iKh/records/README-BANNER-20261010.png)

### Contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing](#pricing)
- [Limits](#limits)
- [API and integrations](#api-and-integrations)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Data source and licence](#data-source-and-licence)
- [Support](#support)

### What it does

The Actor reads the public [USAspending API](https://api.usaspending.gov/) of the U.S. Department of the Treasury. It runs the same award search as the USAspending.gov **Award Search** page, live, one request at a time.

- **Award search.** Pick award types (contracts, IDVs, grants, loans, direct payments, other assistance) and filters. Each award type is searched on its own, and `maxResults` applies to each type.
- **Clear names.** Agency names and abbreviations (`VA`, `NIH`, `DOD`) are checked against the official agency list. A name that does not exist stops the run with suggestions. It does not silently return nothing.
- **Monitoring.** With a `monitorKey`, the Actor saves the awards it saw in your account. The next run marks each award `new`, `updated` or `unchanged`, and by default writes only the new and updated ones.

Awards are money that the government **already awarded**. They are not open tenders or bids. For open opportunities, use SAM.gov.

Prime awards only. Sub-awards are not included, and IDVs (contract vehicles such as GWACs, BPAs and IDIQs) are their own award type, so the same money is not counted twice.

#### Good fit

- See who wins contracts at an agency for your NAICS or PSC codes.
- List all federal awards of a company or university by name or UEI.
- Watch an agency, a competitor or a market every week and get only the changes.
- Find grants or loans of an agency in a period, with the amount obligated and the amount already paid out.

#### Not a fit

- Open tenders, solicitations or bid deadlines. This is award data, not SAM.gov.
- Sub-awards, transaction history or contract officers.
- A full copy of USAspending. Use the official [bulk downloads](https://www.usaspending.gov/download_center/award_data_archive) for that.
- Phone numbers, emails or company ownership data.

### Quick start

1. Open the **Input** tab. The form already has an example: contracts of the Department of Veterans Affairs, NAICS 541512 (computer systems design), last 30 days, 20 awards.
2. Click **Start**.
3. Open the **Awards** view in the Output tab. Check `recipientName`, `awardAmount`, `totalOutlays` and `awardUrl`.
4. Change the agency, codes or recipients to your own. To get only changes next time, add a `monitorKey` such as `va-it-contracts`.

Expected result: 20 award rows in a few seconds, largest awards first.

### Use cases

| Buyer job | Input | Output | Key fields |
| --- | --- | --- | --- |
| Who wins in my market | `awardingAgencies` + `naicsCodes` or `pscCodes` | contract rows | `recipientName`, `recipientUei`, `awardAmount`, `awardingSubAgency` |
| Company due diligence | `recipients` (name or UEI), several `awardTypes` | all award types of that recipient | `awardTypeGroup`, `awardAmount`, `totalOutlays`, `recipientUrl` |
| Grant research | `awardTypes: ["grants"]` + agency + dates | grant rows | `assistanceListings`, `awardAmount`, `totalOutlays`, `description` |
| Weekly competitor watch | filters + `monitorKey`, on a schedule | only new and updated awards | `changeType`, `changedFields`, `previousValues` |

### Input

All filters are optional and combine with AND. Lists inside one filter combine with OR. Without any filter, the run returns the largest awards of the period.

| Field | Type | Default | Allowed values | What it does |
| --- | --- | --- | --- | --- |
| `awardTypes` | array | `["contracts"]` | `contracts`, `idvs`, `grants`, `loans`, `direct_payments`, `other` | Which kinds of awards to search. Each type is a separate search. |
| `awardingAgencies` | array of strings | all agencies | up to 10 | Department or sub-agency, full name or abbreviation: `Department of Veterans Affairs`, `VA`, `National Institutes of Health`, `NIH`. Unknown names stop the run with suggestions. |
| `recipients` | array of strings | all recipients | up to 20 | Recipient name or 12-character UEI. Names use the USAspending text search, so check `recipientName` and `recipientUei`. |
| `naicsCodes` | array of strings | all | up to 50; 2–6 digits | Industry codes. Contracts and IDVs only. |
| `pscCodes` | array of strings | all | up to 50; 1–4 letters or digits | Product and Service Codes, like `DA01`. Contracts and IDVs only. |
| `keywords` | array of strings | none | up to 10; 3–100 characters | Words in the award description and other text fields. |
| `dateFilter` | string | `activity` | `activity`, `new_awards`, `last_modified` | `activity`: any transaction in the range. `new_awards`: the first action is in the range. `last_modified`: the record changed in the range. |
| `lookbackDays` | integer | 30 | 1–3650 | Days back from `dateTo`. Ignored when `dateFrom` is set. |
| `dateFrom`, `dateTo` | date | `dateTo` = today (UTC) | `YYYY-MM-DD` | Exact range. Search data starts on 2007-10-01; earlier dates move to that day. |
| `sortBy` | string | `amount` | `amount`, `last_modified` | Which awards come first when there are more than `maxResults`. Loans sort by face value. |
| `maxResults` | integer | 100 | 1–500 | Maximum awards **per award type**. |
| `monitorKey` | string | none | 1–40 letters, digits or dashes | Saves this run's awards and compares the next run with them. Use one key per saved search. |
| `previousDatasetId` | string | none | dataset ID | Compares with the dataset of an earlier run of this Actor. Use this or `monitorKey`, not both. |
| `onlyChanges` | boolean | `true` | | With a comparison, skip unchanged awards. You do not pay for skipped awards. |

NAICS and PSC exist only on contracts and IDVs. If you add them with other award types, those types are skipped with a warning. If only such types are left, the run stops with `INVALID_INPUT`.

#### Input examples

All awards of one company, by UEI:

```json
{
  "recipients": ["DT2KS3HH5FP5"],
  "awardTypes": ["contracts", "idvs", "grants"],
  "lookbackDays": 365,
  "maxResults": 200
}
```

Weekly watch of new NIH grants, only changes:

```json
{
  "awardTypes": ["grants"],
  "awardingAgencies": ["NIH"],
  "dateFilter": "new_awards",
  "lookbackDays": 30,
  "maxResults": 300,
  "monitorKey": "nih-new-grants"
}
```

### Output

Each Dataset row is **one award**. Use the **Awards** view for the main fields and the **Changes** view for monitoring. The key-value store has a `RUN_SUMMARY` record with the run status and counts.

#### Fields

| Field | Meaning | Example |
| --- | --- | --- |
| `awardTypeGroup` | The award type you selected | `"contracts"` |
| `generatedInternalId` | Stable USAspending award key. Use it to join and compare. | `"CONT_AWD_36C10B21N10150057_3600_VA11816D1015_3600"` |
| `awardId`, `awardType` | PIID or FAIN, and the detailed type | `"36C10B21N10150057"`, `"DELIVERY ORDER"` |
| `recipientName`, `recipientUei`, `recipientId` | Recipient and its IDs | `"BOOZ ALLEN HAMILTON INC"`, `"KHK6E1JW9C15"` |
| `recipientLocation` | City, county, state, ZIP, country, congressional district | `{"city": "EATONTOWN", "stateCode": "NJ", …}` |
| `awardingAgency`, `awardingAgencyCode`, `awardingSubAgency`, `awardingSubAgencyCode` | Agency that made the award | `"Department of Veterans Affairs"` |
| `fundingAgency`, `fundingSubAgency` | Agency that pays | `"Department of Veterans Affairs"` |
| `awardAmount` | Amount **obligated** (committed), in USD. For loans it is `null`; see the loan fields. | `753054309.17` |
| `totalOutlays` | Amount **paid out** so far, in USD. Kept separate from `awardAmount`; never added up. | `561175619.99` |
| `loanFaceValue`, `loanSubsidyCost` | Loans only: face value and subsidy cost | `null` |
| `covid19Obligations`, `infrastructureObligations` | Part of the obligation from COVID-19 or infrastructure (IIJA) funds | `1544364.8` |
| `currency` | Always `USD` | `"USD"` |
| `startDate`, `endDate` | Period of performance (for loans, `startDate` is the issued date). `endDate` is always `null` for IDVs and loans (see Limits). | `"2021-09-30"`, `"2027-09-23"` |
| `lastDateToOrder` | IDVs only: last date to place orders | `null` |
| `baseObligationDate` | Date of the first obligation | `"2021-09-29"` |
| `lastModifiedDate` | When USAspending last changed the record, as published (no time zone) | `"2026-09-25T16:41:40"` |
| `naicsCode`, `naicsDescription`, `pscCode`, `pscDescription` | Contracts and IDVs | `"541512"`, `"DA01"` |
| `assistanceListings` | Grants, loans and other assistance: CFDA / Assistance Listing numbers and titles | `[]` |
| `description` | Award description | `"THE CONTRACTOR SHALL PROVIDE …"` |
| `placeOfPerformance` | Where the work is done | `{"city": "HERNDON", "stateCode": "VA", …}` |
| `awardUrl`, `recipientUrl` | USAspending pages | `"https://www.usaspending.gov/award/CONT_AWD_…"` |
| `source` | Provider, endpoint and `fetchedAt` | |
| `changeType` | `initial` (first monitor run), `new`, `updated`, `unchanged`, or `null` without a comparison | `"updated"` |
| `changedFields`, `previousValues` | For `updated`: which fields changed and their old values | `["totalOutlays"]`, `{"totalOutlays": 540000000}` |

`null` means the source has no value. It never means zero. Negative amounts (de-obligations) are kept as published.

An award is `updated` when one of these fields changes: `awardAmount`, `totalOutlays`, `loanFaceValue`, `loanSubsidyCost`, `startDate`, `endDate`, `lastDateToOrder`, `lastModifiedDate`. An award is `new` when it was not in the saved list; this can also be an older award that has now moved into your top `maxResults`.

#### Output example

A trimmed contract row. The award values are real; the change fields show what a monitor run adds when outlays change:

```json
{
  "changeType": "updated",
  "changedFields": ["totalOutlays", "lastModifiedDate"],
  "awardTypeGroup": "contracts",
  "awardId": "36C10B21N10150057",
  "awardType": "DELIVERY ORDER",
  "recipientName": "BOOZ ALLEN HAMILTON INC",
  "recipientUei": "KHK6E1JW9C15",
  "awardingAgency": "Department of Veterans Affairs",
  "awardAmount": 753054309.17,
  "totalOutlays": 561175619.99,
  "startDate": "2021-09-30",
  "endDate": "2027-09-23",
  "naicsCode": "541512",
  "pscCode": "DA01",
  "awardUrl": "https://www.usaspending.gov/award/CONT_AWD_36C10B21N10150057_3600_VA11816D1015_3600"
}
```

#### Run summary

`RUN_SUMMARY.status` is one of:

| Status | Meaning | Run result |
| --- | --- | --- |
| `COMPLETE` | Rows were written. `truncated: true` means the source has more awards than `maxResults`. | succeeded |
| `NO_RESULTS` | The source answered, and no award matches your filters. | succeeded |
| `NO_CHANGES` | Comparison run: no new or updated awards. | succeeded |
| `PARTIAL` | Some award types failed or time ran out; the rows you got are correct. | succeeded |
| `CAPPED` | Your maximum cost per run was reached. | succeeded |
| `ERROR` | USAspending was not available or changed its format. This is not an empty result. | failed |
| `INVALID_INPUT` | The input is wrong, or an agency name was not found. `message` explains why. | failed |

`RUN_SUMMARY` also has `counts` (fetched, written, charged, new, updated, unchanged), one `groups` entry per award type with its own status, the filters used (with matched agency names), the comparison baseline, `warnings` and the data source.

### Pricing

Pay per event. Platform usage is included.

| Event | Price | When |
| --- | ---: | --- |
| Actor start | $0.002 | Once per run (per GB of memory; the default 256 MB counts once) |
| Award record | $0.002 | Each award row written to the Dataset |

Unchanged awards hidden by `onlyChanges` are free. A run with no results, no changes, an input error or a USAspending error costs only the start.

| Run | Example cost |
| --- | ---: |
| 10 awards | $0.022 |
| 20 awards (form example) | $0.042 |
| 100 awards | $0.202 |
| 1,000 awards (for example 500 contracts + 500 grants) | $2.002 |
| Weekly monitor run with 5 changes | $0.012 |
| No results or no changes | $0.002 |

Set a maximum cost per run in the run options to cap your spend. The Actor stops before a row that does not fit and reports `CAPPED`.

### Limits

- Up to 500 awards per award type, so up to 3,000 rows per run with all six types. In our test, 3,000 rows took about 85 seconds.
- The Actor sends one request at a time, with a pause between requests, and retries when the source is busy. USAspending does not publish a rate limit.
- Internal time budget is 270 seconds. If time runs out, you get the rows found so far and `PARTIAL`.
- If USAspending is down or does not answer (up to 30 seconds per try and about 60 seconds per request in total, at most 3 tries and 2 timeouts), the run stops early and does not ask for the other award types. You get the rows found so far.
- Monitor snapshots keep up to 20,000 awards per `monitorKey`. `previousDatasetId` reads up to 20,000 rows.
- `totalOutlays`, `endDate` and other values come from the USAspending search index. The search index can be behind the award page on USAspending.gov, so outlays on the award page can be higher.
- `endDate` is always `null` for IDVs (use `lastDateToOrder`) and for loans: the search index does not have it.
- Loans have no `awardAmount` in the source. Use `loanFaceValue` and `loanSubsidyCost`. For loans, `startDate` is the loan's issued date.

### API and integrations

Start a run with the same JSON input through the Apify API (`POST /v2/acts/cliqtomedia~usaspending-federal-awards-monitor/runs`), then read the Dataset. Export to CSV, Excel or JSON, or send the rows to Google Sheets, Slack or a webhook with the usual Apify integrations.

For monitoring, save the input as a task with a `monitorKey` and add an Apify schedule (for example every Monday). Each run then gives only new and updated awards. Join rows on `generatedInternalId`.

#### Use with AI agents (MCP)

AI agents can call this Actor through the Apify MCP server: add `https://mcp.apify.com?tools=cliqtomedia/usaspending-federal-awards-monitor` to your MCP client (Claude, Cursor, VS Code and others). The MCP server needs your Apify account (OAuth sign-in or an Apify API token); USAspending itself needs no key. The agent builds the input from the input schema. The smallest useful input:

```json
{ "recipients": ["JOHNS HOPKINS UNIVERSITY"], "awardTypes": ["grants"], "maxResults": 10 }
```

Key output fields for an agent: `recipientName`, `awardTypeGroup`, `awardAmount` (obligated), `totalOutlays` (paid), `awardingAgency`, `startDate`, `awardUrl`, and `RUN_SUMMARY.status`. A call with 10–100 awards usually finishes in under 10 seconds and costs $0.022–$0.202. Very large runs (thousands of rows) can take over a minute, so the agent may need to poll the run for its result.

### Troubleshooting

| Symptom | Check | Action |
| --- | --- | --- |
| `INVALID_INPUT`, agency not found | `RUN_SUMMARY.message` | Use one of the suggested names, or the full official name. |
| `NO_RESULTS` | `RUN_SUMMARY.filters` | Widen the date range, remove a filter, or try `dateFilter: "activity"`. |
| Other recipients than expected | `recipientName`, `recipientUei` | Name search is text search. Use the UEI for an exact recipient. |
| Grants missing with NAICS | `RUN_SUMMARY.warnings` | NAICS and PSC exist only on contracts and IDVs. Remove them for grants. |
| `truncated: true` | `groups[].hasMoreAtSource` | Raise `maxResults` (up to 500) or narrow the filters. |
| Outlays differ from the USAspending award page | `totalOutlays` | The search index can be behind the award page. Open `awardUrl` for the latest value. |
| `ERROR` | `RUN_SUMMARY.message` | USAspending was down or busy. Run again later. Your monitor snapshot is not changed by a failed run. |

### FAQ

#### Are these open tenders I can bid on?

No. These are awards that were already made. For open opportunities, use SAM.gov.

#### What is the difference between `awardAmount` and `totalOutlays`?

`awardAmount` is the money the agency obligated (committed). `totalOutlays` is the money already paid out. They are different numbers, so the Actor never adds them up.

#### Do I need an API key?

No. USAspending is open and free. You only need your Apify account.

#### How fresh is the data?

Each run reads USAspending live. Agencies report awards to USAspending with some delay, so the newest awards can appear days or weeks after they are made. Each row has `lastModifiedDate` (source) and `source.fetchedAt` (our read time).

#### Does monitoring cost more?

No. Unchanged awards are not written and not charged when `onlyChanges` is on.

### Data source and licence

Data: [USAspending.gov](https://www.usaspending.gov/) API, U.S. Department of the Treasury, Bureau of the Fiscal Service. U.S. federal government data is in the public domain. Recipient business names and addresses can include D\&B Open Data. Source of that data: Dun & Bradstreet, Inc. (D\&B). USAspending's [Limitation on Permissible Use of D\&B Data](https://www.usaspending.gov/db_info) asks you to name D\&B when you use it and not to use it in bulk. The Actor does not output DUNS numbers. This Actor is independent and not endorsed by the U.S. Treasury or USAspending.gov.

### Support

Use the **Issues** tab of this Actor. Add the run ID, your input (without private data) and `RUN_SUMMARY.status` and `message`. Do not send API tokens.

# Actor input Schema

## `awardTypes` (type: `array`):

Which kinds of awards to search. Each type is searched separately and maxResults applies per type. Contracts = definitive contracts, purchase and delivery orders; IDVs = indefinite delivery vehicles (GWACs, BPAs, IDIQs); grants = block, formula, project and cooperative agreements; loans = direct and guaranteed loans; direct payments and other assistance = remaining financial assistance. Default: contracts.

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

Up to 10 awarding agencies: official name or abbreviation of a department (e.g. Department of Veterans Affairs, VA, DOD) or of a sub-agency (e.g. National Institutes of Health, NIH). Unknown names stop the run with suggestions instead of silently returning nothing. Default: all agencies.

## `recipients` (type: `array`):

Up to 20 recipient names or 12-character UEIs, e.g. LOCKHEED MARTIN or DT2KS3HH5FP5. Names are matched by USAspending's recipient text search, so check recipientName and recipientUei in the results. Default: all recipients.

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

Up to 50 NAICS industry codes, 2 to 6 digits, e.g. 541512 or 5415. Only contracts and IDVs carry NAICS: other award types are skipped with a warning. Default: all.

## `pscCodes` (type: `array`):

Up to 50 Product and Service Codes, 1 to 4 letters/digits, e.g. DA01, R4 or 7030. Contracts and IDVs only. Default: all.

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

Up to 10 keywords searched in award descriptions and other text fields, e.g. cybersecurity. 3–100 characters each. Default: none.

## `dateFilter` (type: `string`):

What the date range applies to. Activity (default): awards with any transaction (new award, modification, de-obligation) in the range. New awards only: awards whose first action falls in the range. Last modified: awards whose record changed in the range.

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

Date range ending today (or dateTo), 1–3650 days. Ignored when dateFrom is set. Default 30.

## `dateFrom` (type: `string`):

Optional start date YYYY-MM-DD. USAspending search starts at 2007-10-01; earlier dates are moved to that day.

## `dateTo` (type: `string`):

Optional end date YYYY-MM-DD. Default: today (UTC).

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

Which awards come first when there are more than maxResults: largest amount (loans: face value) or most recently modified.

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

Maximum awards returned for each selected award type, 1–500. Default 100. Each award row written to the dataset is charged; unchanged awards hidden by onlyChanges are not.

## `monitorKey` (type: `string`):

Optional name, 1–40 letters, digits or dashes, e.g. va-it-contracts. The Actor stores the awards it saw under this key in your account and the next run with the same key marks each award new, updated or unchanged. The first run marks rows initial. Use one key per saved search.

## `previousDatasetId` (type: `string`):

Optional ID of a dataset from an earlier run of this Actor. Awards are marked new, updated or unchanged against it. Use either this or monitorKey.

## `onlyChanges` (type: `boolean`):

When comparing (monitorKey or previousDatasetId), skip unchanged awards so you only see and pay for changes. Default true. Has no effect without a comparison.

## Actor input object example

```json
{
  "awardTypes": [
    "contracts"
  ],
  "awardingAgencies": [
    "Department of Veterans Affairs"
  ],
  "naicsCodes": [
    "541512"
  ],
  "dateFilter": "activity",
  "lookbackDays": 30,
  "sortBy": "amount",
  "maxResults": 20,
  "onlyChanges": true
}
```

# Actor output Schema

## `awards` (type: `string`):

One row per award with recipient, agencies, obligated amount, outlays, dates, NAICS/PSC and USAspending links.

## `changes` (type: `string`):

Change monitoring view: change type, changed fields and previous values.

## `runSummary` (type: `string`):

Status, counts, truncation per award type, filters used, baseline and source attribution.

# 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 = {
    "awardTypes": [
        "contracts"
    ],
    "awardingAgencies": [
        "Department of Veterans Affairs"
    ],
    "naicsCodes": [
        "541512"
    ],
    "lookbackDays": 30,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/usaspending-federal-awards-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "awardTypes": ["contracts"],
    "awardingAgencies": ["Department of Veterans Affairs"],
    "naicsCodes": ["541512"],
    "lookbackDays": 30,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/usaspending-federal-awards-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 '{
  "awardTypes": [
    "contracts"
  ],
  "awardingAgencies": [
    "Department of Veterans Affairs"
  ],
  "naicsCodes": [
    "541512"
  ],
  "lookbackDays": 30,
  "maxResults": 20
}' |
apify call cliqtomedia/usaspending-federal-awards-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/usaspending-federal-awards-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/uR0Pb0VqayPnggZO9/builds/5vlPcZrbv75lRT5LU/openapi.json