# Bidscout Federal Contracts (`ramosss/bidscout-federal-contracts`) Actor

Find federal incumbents with expiring contracts, score recompete probability, and map competitive landscapes by NAICS. Native MCP server (Claude Desktop, Cursor) + REST API. Procurement intelligence at ~1000× lower cost than $25K/yr legacy platforms.

- **URL**: https://apify.com/ramosss/bidscout-federal-contracts.md
- **Developed by:** [Arthur ramos](https://apify.com/ramosss) (community)
- **Categories:** AI, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $750.00 / 1,000 incumbent detections

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## BidScout Federal Contracts Intelligence

> **Unofficial.** BidScout is an independent third-party tool. It is **not affiliated with, endorsed by, or sponsored by** the U.S. federal government, any U.S. government agency, or any third-party data provider whose public records may be referenced. All trademarks and service marks are the property of their respective owners.

Turn federal government contract data into actionable competitive intelligence. BidScout aggregates and enriches authoritative federal procurement data so government contractors can find opportunities, identify incumbents, and map competitive landscapes — at a fraction of legacy provider pricing.

This Actor runs as a **persistent HTTP API** (Standby mode) and **also speaks the Model Context Protocol** — connect it directly to Claude Desktop, Cursor, or any MCP client.

### What it does

#### 1. Search Federal Opportunities — `tool-call-search`
Searches active federal contract opportunities. Filter by keyword, NAICS code, set-aside type, agency, and state.

#### 2. Detect Incumbent Contractors — `tool-call-incumbents`
Identifies current contractors with expiring federal contracts and calculates a **proprietary recompete probability score (0-100)** based on proximity to expiration, contract value, and duration. This is competitive intelligence that typically costs $25K/yr from legacy providers like GovWin.

#### 3. Analyze Competitive Landscape — `tool-call-landscape`
Comprehensive market intelligence: total market size, top agencies by spend, top contractors by value won, expiring contracts summary, and strategic insights.

### Use cases

- Government contractors looking for upcoming recompete opportunities
- Business development teams mapping competitive landscapes by NAICS
- Small businesses finding set-aside opportunities (8(a), WOSB, SDVOSBC, HUBZone)
- AI agents that need federal procurement intelligence as a tool

### Pricing — Pay Per Event

| Event | Price | What you get |
|---|---|---|
| `tool-call-search` | **$0.03** | One federal opportunity search |
| `tool-call-incumbents` | **$0.75** | One incumbent-detection run with proprietary recompete scoring (vs $25K/yr legacy = ~1000× cheaper) |
| `tool-call-landscape` | **$0.12** | One landscape briefing with aggregated market intelligence |

Monitor your spend in real time from the Apify Console billing dashboard. The Actor returns HTTP `402` (or an MCP error) if the platform reports a per-event budget cap was reached.

### How to use it

#### Option A — MCP client (Claude Desktop / Cursor / mcp-inspector)

Add to your MCP client config. Example for Claude Desktop (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "bidscout": {
      "url": "https://<your-actor-id>.apify.actor/mcp",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
````

Restart your MCP client. Then ask the model things like:

- *"Find incumbent contractors in NAICS 541512 with contracts expiring in the next 6 months."*
- *"Show me the competitive landscape for cybersecurity contracts, top 10 contractors over 3 years."*

#### Option B — REST API (curl / your own SDK)

**Search opportunities:**

```bash
curl -X POST "https://<your-actor-id>.apify.actor/search" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -d '{"keyword": "cybersecurity", "naicsCode": "541512"}'
```

**Detect incumbents (the high-value call):**

```bash
curl -X POST "https://<your-actor-id>.apify.actor/incumbents" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -d '{"naicsCode": "541512", "expiringWithinMonths": 12}'
```

**Competitive landscape:**

```bash
curl -X POST "https://<your-actor-id>.apify.actor/landscape" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -d '{"naicsCode": "541512", "lookbackYears": 3}'
```

**Discover capabilities:**

```bash
curl "https://<your-actor-id>.apify.actor/tools"
```

#### Option C — Batch run (Apify Console / scheduled task)

Use the Input form to pick an `action` and parameters. Results are pushed to the default dataset. Each batch run triggers the same Pay-Per-Event charge as a single HTTP call.

# Actor input Schema

## `action` (type: `string`):

Which analysis to run

## `keyword` (type: `string`):

Search term for opportunity titles or contract descriptions (e.g. 'cybersecurity', 'cloud migration')

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

6-digit NAICS industry code (e.g. '541512' for Computer Systems Design)

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

Federal agency name to filter results

## `setAside` (type: `string`):

Filter by set-aside (small business programs)

## `state` (type: `string`):

2-letter state code for place of performance (e.g. 'VA', 'CA')

## `postedWithinDays` (type: `integer`):

Only show opportunities posted within N days (for search\_opportunities)

## `expiringWithinMonths` (type: `integer`):

Look-ahead window for expiring contracts (for detect\_incumbents)

## `lookbackYears` (type: `integer`):

Years of historical data to analyze (for competitive\_landscape)

## Actor input object example

```json
{
  "action": "search_opportunities",
  "keyword": "cybersecurity",
  "naicsCode": "541512",
  "setAside": "",
  "postedWithinDays": 30,
  "expiringWithinMonths": 12,
  "lookbackYears": 3
}
```

# Actor output Schema

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

Tool results pushed to the default dataset (see Dataset tab for the typed schema and pivoted views)

# 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 = {
    "keyword": "cybersecurity",
    "naicsCode": "541512"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ramosss/bidscout-federal-contracts").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 = {
    "keyword": "cybersecurity",
    "naicsCode": "541512",
}

# Run the Actor and wait for it to finish
run = client.actor("ramosss/bidscout-federal-contracts").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 '{
  "keyword": "cybersecurity",
  "naicsCode": "541512"
}' |
apify call ramosss/bidscout-federal-contracts --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bidscout Federal Contracts",
        "description": "Find federal incumbents with expiring contracts, score recompete probability, and map competitive landscapes by NAICS. Native MCP server (Claude Desktop, Cursor) + REST API. Procurement intelligence at ~1000× lower cost than $25K/yr legacy platforms.",
        "version": "1.1",
        "x-build-id": "eduRaiyTStTVEClx4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ramosss~bidscout-federal-contracts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ramosss-bidscout-federal-contracts",
                "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/ramosss~bidscout-federal-contracts/runs": {
            "post": {
                "operationId": "runs-sync-ramosss-bidscout-federal-contracts",
                "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/ramosss~bidscout-federal-contracts/run-sync": {
            "post": {
                "operationId": "run-sync-ramosss-bidscout-federal-contracts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search_opportunities",
                            "detect_incumbents",
                            "competitive_landscape"
                        ],
                        "type": "string",
                        "description": "Which analysis to run",
                        "default": "search_opportunities"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search term for opportunity titles or contract descriptions (e.g. 'cybersecurity', 'cloud migration')"
                    },
                    "naicsCode": {
                        "title": "NAICS Code",
                        "type": "string",
                        "description": "6-digit NAICS industry code (e.g. '541512' for Computer Systems Design)"
                    },
                    "agency": {
                        "title": "Agency Filter",
                        "type": "string",
                        "description": "Federal agency name to filter results"
                    },
                    "setAside": {
                        "title": "Set-Aside Type",
                        "enum": [
                            "",
                            "SBA",
                            "8A",
                            "WOSB",
                            "SDVOSBC",
                            "HZC"
                        ],
                        "type": "string",
                        "description": "Filter by set-aside (small business programs)",
                        "default": ""
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "2-letter state code for place of performance (e.g. 'VA', 'CA')"
                    },
                    "postedWithinDays": {
                        "title": "Posted Within Days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only show opportunities posted within N days (for search_opportunities)",
                        "default": 30
                    },
                    "expiringWithinMonths": {
                        "title": "Expiring Within Months",
                        "minimum": 1,
                        "maximum": 36,
                        "type": "integer",
                        "description": "Look-ahead window for expiring contracts (for detect_incumbents)",
                        "default": 12
                    },
                    "lookbackYears": {
                        "title": "Lookback Years",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Years of historical data to analyze (for competitive_landscape)",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```