# Federal Award Counterparty MCP Server (`nexgenwatch/federal-award-counterparty-mcp`) Actor

Answer questions about US federal award recipients from USAspending.gov: who won awards from an agency, one organisation's award history, and who that recipient actually is on the federal register.

- **URL**: https://apify.com/nexgenwatch/federal-award-counterparty-mcp.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Agents, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 tool calls

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Federal Award Counterparty MCP Server

Answer questions about **US federal award recipients** — who won awards from an agency, what
one organisation has been awarded, and who that organisation actually is on the federal
register — from USAspending.gov, live.

Built for sales teams qualifying government contractors, and for anyone who needs the award
side of a counterparty before signing something.

### Three things this server gets right that a naive read gets wrong

Every one of these was measured live against the source on 2026-07-30, and each one changes
the answer.

#### 1. "Last 12 months" does not mean "awarded in the last 12 months"

USAspending's default time filter matches awards with **any activity** in the window — so an
old contract that saw a modification comes back as though it were new. Measured, same
recipient, same 365-day window:

```
source default            -> awards starting 2017-11-17, 2019-11-26, 2022-12-23
date_type=new_awards_only -> awards starting 2026-04-09, 2025-09-12, 2025-08-01
```

Asked "who won work from this agency last year", the first answer names incumbents from three
administrations ago. **This server sends `new_awards_only` by default**, states which clock
produced every answer, and makes you opt into the loose one by name.

#### 2. A recipient name is a search key, not an identity

`recipient_search_text` is a fuzzy match. Measured: searching **`LOCKHEED`** returns
**`RAYTHEON/LOCKHEED MARTIN JAVELIN JV`** — a different legal entity. Every row reports the
name actually matched, and the tools point you at the **UEI** as the identity.

#### 3. A parent and its children are different companies on this register

USAspending publishes a parent (`P`) and each child (`C`) as separate recipients, with separate
UEIs and separate totals. Measured on one trading name: three rows, three UEIs, totals of
$64.8bn, $27.0bn and $16.7bn. A single number for "the company" depends entirely on which
row you meant, so **the level is always reported and the rows are never merged**.

### Tools

| tool | what it answers |
|---|---|
| `find_recipient` | Recipients matching a name, each with UEI, parent/child level and total awarded |
| `get_recipient_profile` | Full profile for one recipient: UEI, DUNS, business types, parent, location, lifetime totals |
| `get_award_history` | Awards to one recipient in a trailing window, largest first |
| `get_agency_top_recipients` | Who won awards from one federal agency in a trailing window |
| `list_agencies` | Every top-tier agency, with the exact spelling the agency tool needs |
| `explain_limits` | What this server will and will not say, and the three traps above. Read before acting. |

Award families: `contracts` (default), `grants`, `direct_payments`, `loans`, `other`. An
unrecognised family is refused rather than silently defaulted.

### Scope

**US federal PRIME awards published on USAspending.gov. One jurisdiction.** Every query sends
`subawards=False`, so a subcontractor on a federal prime contract does not appear here and this
server does not imply otherwise.

This server reports what USAspending publishes. It does **not** certify that an organisation is
or is not a federal contractor, does not decide that two similarly named recipients are the same
entity, and says nothing about award performance, quality or compliance.

Source, public and logged-out, no key: `api.usaspending.gov/api/v2`. `robots.txt` on that host
is 404 — no Disallow and no Crawl-delay — and every outbound call is paced anyway through one
shared strict-pacing bucket at **5 requests/second**.

### Pricing

| Event | Price |
|---|---|
| Server start (`apify-actor-start`) | $0.05, charged once per server run by the platform |
| Tool call (`mcp-tool-call`) | **$0.05 flat per completed tool call** |

No other events. Memory is pinned to 1024 MB so the start fee is charged **once** — on this
platform the start event bills once per gigabyte.

**Errors and notices are not charged.** An empty name, an unknown award family, or a USAspending
read failure returns without billing.

**A sourced "no results" IS charged.** Zero rows from a successful read is the honest answer to
the question asked — the register publishes nothing matching — and it is billed as an answer,
not given away as a failure.

If a tool call cannot be billed correctly, **the call fails** rather than serving free.

# Actor input Schema

## `note` (type: `string`):

This Actor runs as an MCP server in Standby mode. Connect an MCP client to the server URL with path /mcp; there is no batch input to fill in.

## Actor input object example

```json
{
  "note": "standby"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "note": "standby"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/federal-award-counterparty-mcp").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 = { "note": "standby" }

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/federal-award-counterparty-mcp").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 '{
  "note": "standby"
}' |
apify call nexgenwatch/federal-award-counterparty-mcp --silent --output-dataset

```

## MCP server setup

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

```

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/GvJbRHzP0ObCv6sTS/builds/CngZPphf3l3VQGdu5/openapi.json