# Federal Contracts Intelligence: SAM.gov, NAICS, FPDS (`andrew_avina/federal-contracts-mcp`) Actor

Query every federal contract from SAM.gov + USASpending ($800B/yr). Returns vendor, agency, NAICS, contract type, set-aside (SDVOSB/8a/HUBZone), period of performance. Filter by agency, NAICS, amount, state. MCP-native. FY2000-present.

- **URL**: https://apify.com/andrew\_avina/federal-contracts-mcp.md
- **Developed by:** [Andrew Avina](https://apify.com/andrew_avina) (community)
- **Categories:** MCP servers, Business, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## federal-contracts-mcp

**The $800B federal contracting market, searchable in seconds.**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/store)
[![Pricing](https://img.shields.io/badge/Pricing-from%20%240.50%2F1k%20results-blue)](https://apify.com/pricing)
[![Data Source](https://img.shields.io/badge/Data-USASpending.gov-orange)](https://www.usaspending.gov)
[![Category](https://img.shields.io/badge/Category-Government%20%2F%20GovCon-purple)](https://apify.com/store)
[![MCP Ready](https://img.shields.io/badge/MCP-Server%20Ready-red)](https://modelcontextprotocol.io)

---

### What Is This?

The US federal government awards more than **$800 billion in contracts every year** across thousands of agencies, programs, and NAICS categories. That data is technically public — posted to USASpending.gov — but querying it directly means wrestling with a complex REST API, navigating opaque filter syntax, paginating through thousands of results, and manually reconciling award data with contractor identifiers. Most BD teams either pay five-figure subscriptions to GovCon databases or skip the research entirely.

This actor wraps USASpending.gov's Award Search API into a clean, filterable interface that returns structured contract award data in seconds. Filter by agency, NAICS code, PSC code, contractor name, award amount range, and fiscal year — then get normalized output with every field your pipeline needs: award ID, recipient name, award amount, awarding agency, NAICS code, and contract start date. No API key required for the underlying source. No data normalization work on your end.

It ships in two modes: **Batch mode** for one-shot research runs (export to JSON, feed a spreadsheet, trigger a workflow), and **MCP server mode** for live tool-use inside Claude Desktop, Claude Code, or any MCP-compatible AI agent. GovCon analysts, BD directors, and prime contractor business development teams use this to map competitive landscapes, size addressable markets, and build prospect pipelines — without ever leaving their AI assistant.

---

### Who Uses This

**Government Contractor BD Directors**
You need to know who is winning NAICS 541512 (computer systems design) contracts at DHS before your next proposal. Currently you're either paying $15K/year for Deltek GovWin or manually exporting CSVs from SAM.gov. This actor returns every award in that NAICS at that agency for the last 3 fiscal years in one call — sorted by award amount, with recipient names you can match against your teaming pipeline.

**Prime Contractor Competitive Intelligence Teams**
You need to know which small businesses are winning SBIR awards in your product space so you can evaluate acquisition targets or teaming partners. A single filtered query returns award amounts, recipient names, and start dates for every relevant contract — ready to feed your CRM or a downstream enrichment workflow.

**Market Sizing Analysts**
You're building a TAM model for a federal IT services pitch deck. You need total obligated dollars in NAICS 541511 over the last 5 fiscal years, broken down by agency. This actor returns that data structured and ready to aggregate — no pivot tables, no manual data cleaning.

**Grant and Contract Writers at Research Universities**
You need to understand the funding landscape before writing a proposal — who got awards in your research area, from which agencies, at what funding levels. This actor gives you a peer landscape analysis in under a minute.

**Investigative Journalists and Policy Researchers**
You're tracking contractor concentration in defense spending, or following the money on a specific federal program. Filter by agency + PSC code + fiscal year and get every award in scope, ready for analysis.

---

### Key Features

| Feature | Detail |
|---|---|
| Data coverage | $800B+/year in federal prime contract awards via USASpending.gov |
| Filter: Agency | Any federal agency (DOD, DHS, HHS, NASA, VA, etc.) |
| Filter: NAICS code | 6-digit NAICS for industry-specific searches |
| Filter: PSC code | Product/Service Code for procurement category filtering |
| Filter: Contractor name | Substring or exact match on recipient name |
| Filter: Award amount range | Min/max dollar thresholds |
| Filter: Fiscal year | Single year or multi-year range (FY2015â€“FY2025) |
| Output format | Normalized JSON with all required award fields |
| MCP server mode | Live tool-use in Claude Desktop, Claude Code, any MCP client |
| Batch mode | One-shot runs exportable to JSON/CSV |
| Pagination | Handles USASpending pagination automatically |
| Rate limiting | Built-in retry logic with exponential backoff |

---

### Quick Start

#### Batch Mode

**Input:**
```json
{
  "mode": "batch",
  "agency": "Department of Homeland Security",
  "naics_code": "541512",
  "fiscal_year_start": 2022,
  "fiscal_year_end": 2024,
  "award_amount_min": 1000000,
  "award_amount_max": 50000000,
  "max_results": 50
}
````

**Output (truncated to 2 records):**

```json
[
  {
    "award_id": "HSHQDC-23-C-00041",
    "recipient_name": "Accenture Federal Services LLC",
    "award_amount": 18450000,
    "awarding_agency": "Department of Homeland Security",
    "naics_code": "541512",
    "psc_code": "D307",
    "start_date": "2023-03-15",
    "period_of_performance_end": "2026-03-14",
    "description": "IT Systems Integration and Modernization Support"
  },
  {
    "award_id": "HSHQDC-22-C-00089",
    "recipient_name": "Leidos Inc.",
    "award_amount": 12800000,
    "awarding_agency": "Department of Homeland Security",
    "naics_code": "541512",
    "psc_code": "D301",
    "start_date": "2022-09-01",
    "period_of_performance_end": "2025-08-31",
    "description": "Cybersecurity Operations Center Support"
  }
]
```

#### MCP Server Mode

Add to your Claude Desktop `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "federal-contracts": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/federal-contracts-mcp",
        "--token", "YOUR_APIFY_TOKEN"
      ]
    }
  }
}
```

Then in Claude: *"Search for NAICS 541330 engineering contracts at the Army Corps of Engineers over $5M awarded in FY2024."*

***

### MCP Tools Exposed

#### `search_federal_contracts`

Search and filter federal contract awards from USASpending.gov.

```json
{
  "tool": "search_federal_contracts",
  "arguments": {
    "agency": "Department of Defense",
    "naics_code": "541330",
    "fiscal_year_start": 2024,
    "fiscal_year_end": 2024,
    "award_amount_min": 5000000,
    "max_results": 25
  }
}
```

#### `get_contract_detail`

Retrieve full details for a specific award by ID.

```json
{
  "tool": "get_contract_detail",
  "arguments": {
    "award_id": "W912DR-24-C-0012"
  }
}
```

#### `summarize_agency_spend`

Return total obligated dollars and award count for an agency + optional NAICS/PSC filter across a fiscal year range.

```json
{
  "tool": "summarize_agency_spend",
  "arguments": {
    "agency": "Department of Veterans Affairs",
    "naics_code": "621111",
    "fiscal_year_start": 2020,
    "fiscal_year_end": 2024
  }
}
```

#### `top_contractors`

Return the top N contractors by total award amount for a given set of filters.

```json
{
  "tool": "top_contractors",
  "arguments": {
    "agency": "NASA",
    "fiscal_year_start": 2022,
    "fiscal_year_end": 2024,
    "top_n": 10
  }
}
```

***

### Input Schema

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `"batch"` | `"batch"` or `"mcp"` |
| `agency` | string | — | Federal agency name (partial match supported) |
| `naics_code` | string | — | 6-digit NAICS code |
| `psc_code` | string | — | Product/Service Code (4-char) |
| `contractor_name` | string | — | Recipient name substring search |
| `award_amount_min` | number | — | Minimum total obligated amount (USD) |
| `award_amount_max` | number | — | Maximum total obligated amount (USD) |
| `fiscal_year_start` | integer | — | Start of fiscal year range (e.g. 2020) |
| `fiscal_year_end` | integer | — | End of fiscal year range (e.g. 2024) |
| `max_results` | integer | `100` | Maximum records to return (up to 10,000) |
| `sort_by` | string | `"award_amount"` | Sort field: `award_amount`, `start_date`, `recipient_name` |
| `sort_order` | string | `"desc"` | `"asc"` or `"desc"` |

***

### Use Case Recipes

#### Recipe 1: Competitive Landscape for a Proposal

Map every competitor winning NAICS 541511 work at DoD over $2M in the last 2 fiscal years:

```json
{
  "agency": "Department of Defense",
  "naics_code": "541511",
  "fiscal_year_start": 2023,
  "fiscal_year_end": 2024,
  "award_amount_min": 2000000,
  "sort_by": "award_amount",
  "max_results": 200
}
```

**Outcome:** Ranked list of recipients with award amounts — tells you who dominates the space and at what contract sizes.

#### Recipe 2: Expiring Contract Pipeline

Find contracts awarded in FY2022 that are likely entering option year or recompete territory:

```json
{
  "agency": "Department of Homeland Security",
  "fiscal_year_start": 2022,
  "fiscal_year_end": 2022,
  "award_amount_min": 5000000,
  "sort_by": "start_date"
}
```

**Outcome:** Contracts now 2+ years old — prime recompete targets for BD pipeline.

#### Recipe 3: Small Business Market Entry Research

Find all awards under $500K in NAICS 541714 (R\&D in biotechnology) at NIH:

```json
{
  "agency": "National Institutes of Health",
  "naics_code": "541714",
  "award_amount_max": 500000,
  "fiscal_year_start": 2022,
  "fiscal_year_end": 2024
}
```

**Outcome:** SBIR/STTR and small prime landscape — identify teaming partners or set-aside opportunities.

#### Recipe 4: TAM Calculation for Federal Vertical

Total obligated spend in facilities management (PSC code S201) across all civilian agencies FY2020â€“FY2024:

```json
{
  "psc_code": "S201",
  "fiscal_year_start": 2020,
  "fiscal_year_end": 2024,
  "max_results": 5000
}
```

**Outcome:** Aggregate this output to get a 5-year TAM with year-over-year trend for an investor deck.

***

### Connecting to Claude Desktop / Claude Code

**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, `%APPDATA%\Claude\claude_desktop_config.json` on Windows):

```json
{
  "mcpServers": {
    "federal-contracts": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/federal-contracts-mcp",
        "--token", "apify_api_YOURTOKEN"
      ],
      "env": {}
    }
  }
}
```

**Claude Code** (add to project `.claude/settings.json`):

```json
{
  "mcpServers": {
    "federal-contracts": {
      "command": "npx",
      "args": ["apify-actor-mcp", "--actor-id", "your-username/federal-contracts-mcp", "--token", "apify_api_YOURTOKEN"]
    }
  }
}
```

Once connected, ask Claude: *"Who are the top 10 contractors winning IT services work at the VA in FY2024?"* — Claude will call the tool and return structured results in plain language.

***

### Pricing

| Volume | Price |
|---|---|
| First 1,000 results | $0.50 |
| 1,001 â€“ 50,000 results | $0.40/1k |
| 50,000+ results | $0.30/1k |
| MCP server (per session-hour) | Metered by result count |

**ROI context:** A single GovWin IQ subscription runs $12,000â€“$20,000/year. A BD analyst spending 4 hours manually pulling USASpending data earns that back at $150/hr in 20 minutes. This actor pays for itself on the first query.

***

### Data Source and Freshness

- **Primary:** USASpending.gov Award Search API (v2) — official federal procurement data published by the Department of Treasury
- **Update frequency:** USASpending.gov updates daily; actor reflects data as of prior business day
- **Historical depth:** FY2001 to present (awards prior to FY2008 have limited metadata)
- **Coverage:** All federal prime contract awards over $10,000 (mandatory reporting threshold); includes IDIQs, task orders, grants, and direct awards

***

### Technical Notes

- No API key required for USASpending.gov — the actor handles all authentication internally
- Large queries (10,000+ records) use cursor-based pagination and may take 30â€“90 seconds
- NAICS codes should be 6-digit strings (e.g., `"541512"` not `541512`)
- Agency names use USASpending's canonical naming — partial matches are supported but exact matches are faster
- Award amounts reflect total obligated value, not ceiling (IDIQ ceilings are noted separately when available)
- The actor normalizes all currency fields to USD integers

***

### Support

- **Issues:** File a GitHub issue on the actor repository
- **Apify Community:** [community.apify.com](https://community.apify.com)
- **USASpending API docs:** [api.usaspending.gov](https://api.usaspending.gov)
- **Enterprise / custom integrations:** Contact via Apify actor page

# Actor input Schema

## `query` (type: `string`):

Search keyword matched against recipient name, award description, agency, NAICS, and PSC fields. Examples: 'cybersecurity', 'artificial intelligence', 'logistics support', 'cloud computing'.

## `agency` (type: `string`):

Filter by awarding agency name. Examples: 'Department of Defense', 'NASA', 'Department of Homeland Security', 'Health and Human Services', 'General Services Administration'.

## `naicsCode` (type: `string`):

6-digit North American Industry Classification System code. Examples: '541512' (Computer Systems Design), '541715' (R\&D in Physical Sciences), '336411' (Aircraft Manufacturing), '611420' (Computer Training).

## `pscCode` (type: `string`):

Product/Service Code classifying the type of product or service procured. Examples: 'D307' (IT/Telecom - Systems Analysis), 'R425' (Professional: Engineering/Technical), 'AC13' (R\&D - Physical Sciences).

## `minAmount` (type: `integer`):

Only return contracts with award amount >= this value in USD. Use 1000000 to filter for million-dollar+ contracts.

## `maxAmount` (type: `integer`):

Only return contracts with award amount <= this value in USD. Set to 0 for no upper limit.

## `fiscalYear` (type: `integer`):

US federal fiscal year to query (Oct 1 – Sep 30). Defaults to FY2024. Range: 2000–present.

## `limit` (type: `integer`):

Maximum number of contract awards to return (max 500). In MCP server mode, up to 1000 records are loaded into memory for real-time queries.

## `serveMcp` (type: `boolean`):

When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to live federal contracting data. The actor will run continuously until stopped.

## Actor input object example

```json
{
  "query": "",
  "agency": "",
  "naicsCode": "",
  "pscCode": "",
  "minAmount": 0,
  "maxAmount": 0,
  "fiscalYear": 2024,
  "limit": 100,
  "serveMcp": false
}
```

# 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("andrew_avina/federal-contracts-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=andrew_avina/federal-contracts-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Contracts Intelligence: SAM.gov, NAICS, FPDS",
        "description": "Query every federal contract from SAM.gov + USASpending ($800B/yr). Returns vendor, agency, NAICS, contract type, set-aside (SDVOSB/8a/HUBZone), period of performance. Filter by agency, NAICS, amount, state. MCP-native. FY2000-present.",
        "version": "0.0",
        "x-build-id": "9BgudqC2i9a7WNNc0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/andrew_avina~federal-contracts-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-andrew_avina-federal-contracts-mcp",
                "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/andrew_avina~federal-contracts-mcp/runs": {
            "post": {
                "operationId": "runs-sync-andrew_avina-federal-contracts-mcp",
                "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/andrew_avina~federal-contracts-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-andrew_avina-federal-contracts-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Keyword Search",
                        "type": "string",
                        "description": "Search keyword matched against recipient name, award description, agency, NAICS, and PSC fields. Examples: 'cybersecurity', 'artificial intelligence', 'logistics support', 'cloud computing'.",
                        "default": ""
                    },
                    "agency": {
                        "title": "Awarding Agency",
                        "type": "string",
                        "description": "Filter by awarding agency name. Examples: 'Department of Defense', 'NASA', 'Department of Homeland Security', 'Health and Human Services', 'General Services Administration'.",
                        "default": ""
                    },
                    "naicsCode": {
                        "title": "NAICS Code",
                        "type": "string",
                        "description": "6-digit North American Industry Classification System code. Examples: '541512' (Computer Systems Design), '541715' (R&D in Physical Sciences), '336411' (Aircraft Manufacturing), '611420' (Computer Training).",
                        "default": ""
                    },
                    "pscCode": {
                        "title": "PSC Code",
                        "type": "string",
                        "description": "Product/Service Code classifying the type of product or service procured. Examples: 'D307' (IT/Telecom - Systems Analysis), 'R425' (Professional: Engineering/Technical), 'AC13' (R&D - Physical Sciences).",
                        "default": ""
                    },
                    "minAmount": {
                        "title": "Minimum Award Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return contracts with award amount >= this value in USD. Use 1000000 to filter for million-dollar+ contracts.",
                        "default": 0
                    },
                    "maxAmount": {
                        "title": "Maximum Award Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return contracts with award amount <= this value in USD. Set to 0 for no upper limit.",
                        "default": 0
                    },
                    "fiscalYear": {
                        "title": "Fiscal Year",
                        "minimum": 2000,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "US federal fiscal year to query (Oct 1 – Sep 30). Defaults to FY2024. Range: 2000–present.",
                        "default": 2024
                    },
                    "limit": {
                        "title": "Result Limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of contract awards to return (max 500). In MCP server mode, up to 1000 records are loaded into memory for real-time queries.",
                        "default": 100
                    },
                    "serveMcp": {
                        "title": "MCP Server Mode",
                        "type": "boolean",
                        "description": "When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to live federal contracting data. The actor will run continuously until stopped.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
