# Expiring Federal Contracts: Recompete Finder (USAspending) (`fedsignals/federal-recompete-finder`) Actor

Returns federal contracts whose performance period ends soon (likely recompetes): incumbent, value, agency, end date, days left, NAICS/PSC, place of performance and a USAspending link. Filter by category, NAICS, agency, state, keyword and value.

- **URL**: https://apify.com/fedsignals/federal-recompete-finder.md
- **Developed by:** [FedSignals Data](https://apify.com/fedsignals) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 expiring contract leads

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

## Expiring Federal Contracts: Recompete Finder (USAspending)

List federal contracts whose period of performance **ends soon**. These are the deals that agencies typically re-compete. You can filter by category, PSC code, NAICS, set-aside, incumbent (name or UEI), agency, state, keyword and minimum value. Each lead gives the incumbent, value, end date, agency, a USAspending link and a SAM.gov search link for the matching notice. Incremental mode alerts you only to contracts you haven't seen, and alerts you again if an end date changes.

### Why it matters

Recompetes are the best-qualified pipeline in government contracting. The requirement already exists, the budget is known, and the incumbent can be studied. Firms typically start capture 6–18 months before the end date.

### Example input

```json
{
  "categories": ["IT & Cyber"],
  "endsAfterDays": 180,
  "endsWithinDays": 540,
  "minAwardAmount": 5000000,
  "agencies": [],
  "placeOfPerformanceStates": [],
  "onlyNew": true,
  "maxItems": 500
}
```

### Example output

```json
{
  "awardId": "205AE926F00059",
  "recipient": "CTG FEDERAL, LLC",
  "awardAmount": 9900022.76,
  "awardType": "DELIVERY ORDER",
  "awardingAgency": "Department of the Treasury",
  "awardingSubAgency": "Internal Revenue Service",
  "endDate": "2027-04-26",
  "daysUntilEnd": 180,
  "category": "IT & Cyber",
  "naicsCode": "541519",
  "pscCode": "7B22",
  "placeOfPerformanceState": "WV",
  "description": "PROCUREMENT OF 18 HPE SERVERS AND WARRANTIES",
  "usaspendingUrl": "https://www.usaspending.gov/award/CONT_AWD_205AE926F00059_2050_NNG15SD12B_8000"
}
```

A live test on Oct 28, 2026 for IT & Cyber contracts of $5M or more ending in 6–18 months returned 100 leads (capped by `maxItems`) in about 22 seconds.

### Use cases

- Small and mid-size contractors building a capture pipeline.
- Teaming and partnership outreach to incumbents ahead of recompetes.
- BD consultants packaging recompete lists for clients.

### Data source and caveats

The data comes from the **USAspending.gov API** (U.S. Department of the Treasury). It is public U.S. government data, and no key is required. The end date is the *current* period-of-performance end. Unexercised options, extensions or bridge contracts can move it, and an expiring order on an IDIQ may be re-issued under the same vehicle rather than openly re-competed. The USAspending API returns at most 10,000 results per sort order. The Actor reads from both ends of the window, and the run summary's `windowFullyCovered` tells you whether a very broad search was truncated. If it was, narrow the filters.

### Scheduling

Run **weekly** with `onlyNew: true`. The first run returns your full window; later runs return only new or changed contracts.

### How much does it cost?

Pay per event: you pay only for the events below plus Apify's $0.00005 run-start fee. Platform compute is included in the price.

- **$0.01 per expiring-contract lead** delivered.

Real examples from our test runs:

- **Quick-start input** (10 contracts): 10 × $0.01 = **about $0.10**.
- **IT & Cyber, $5M+, ending in 6-18 months**: our Oct 28 test hit the 100-lead cap in about 22 seconds = **$1.00** for 100 leads.
- **Weekly incremental run**: only new or changed contracts are charged, usually a small fraction of the first run.

Use `maxItems` and Apify's per-run spending limit to cap spend; the Actor stops cleanly when the limit is reached.

### Limits

- USAspending pages through at most 10,000 results per sort order. The Actor reads from both ends of the date window, so it covers up to 20,000 contracts per search; broader searches are truncated and flagged in the summary and status message.
- `samSearchUrl` is a SAM.gov search for the contract number, not a guaranteed match: many task orders were never posted on SAM.gov.
- The set-aside filter uses USAspending's set-aside field; contracts awarded without one only appear when `setAsides` is empty.
- The same company can appear under several names or UEIs.

### FAQ

**What is a recompete?**\
When a federal contract ends, the agency usually competes the work again. Knowing the end date 6-18 months ahead gives you time to prepare a bid.

**Where does the data come from?**\
The official USAspending.gov API. No key is needed.

**Is the end date final?**\
No. It is the current period-of-performance end. Options, extensions and bridge contracts can move it, and some orders are re-issued on the same vehicle instead of openly re-competed.

**Can I filter by PSC code, set-aside or incumbent?**\
Yes. `pscCodes` takes full codes (D399) or prefixes (D3, R4, 70). `setAsides` takes groups such as 8(a), sdvosb or wosb, or raw codes. `incumbents` takes company names (partial match) or UEIs, so you can watch a competitor's contracts as they near their end date.

**How do I find the SAM.gov notice for a contract?**\
Open `samSearchUrl`. It searches SAM.gov Contract Opportunities, active and archived, for the contract number, which finds the award notice and often the follow-on notice. To track the follow-on solicitation itself, use Federal Opportunities Monitor with the agency and NAICS.

**How do I know a broad search was complete?**\
The run summary includes `windowFullyCovered`. If it is false, the search matched more than the 20,000 contracts the Actor can read per search; narrow your filters.

### Reliability

Measured on Apify as of Oct 29, 2026: 3 of 3 of our own test runs succeeded (100%), with a median run time of 28 seconds (longest 82 s) on small test inputs. It is a small sample from a new Actor; we will update it as runs accumulate. Local tests: IT & Cyber $5M+ returned 100 leads in about 22 seconds with 0 API errors.

### Use it from AI agents (MCP)

Add this Actor as a tool in Claude Desktop, Cursor or any MCP client through the Apify MCP server:

```json
{
  "mcpServers": {
    "federal-recompete-finder": {
      "url": "https://mcp.apify.com?tools=fedsignals/federal-recompete-finder",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

### Use it from code (API)

One call runs the Actor and returns the dataset items. `maxTotalChargeUsd` caps what the run can charge.

Python:

```python
import requests

items = requests.post(
    "https://api.apify.com/v2/acts/fedsignals~federal-recompete-finder/run-sync-get-dataset-items",
    params={"maxTotalChargeUsd": 1},
    headers={"Authorization": "Bearer YOUR_APIFY_TOKEN"},
    json={"categories": ["IT & Cyber"], "minAwardAmount": 5000000, "onlyNew": False, "maxItems": 10, "maxScan": 2000},
    timeout=300,
).json()
print(len(items), "items")
```

JavaScript (Node 18+):

```js
const res = await fetch(
  "https://api.apify.com/v2/acts/fedsignals~federal-recompete-finder/run-sync-get-dataset-items?maxTotalChargeUsd=1",
  {
    method: "POST",
    headers: { Authorization: "Bearer YOUR_APIFY_TOKEN", "Content-Type": "application/json" },
    body: JSON.stringify({"categories": ["IT & Cyber"], "minAwardAmount": 5000000, "onlyNew": false, "maxItems": 10, "maxScan": 2000}),
  }
);
const items = await res.json();
console.log(items.length, "items");
```

### Related FedSignals Actors

- [SAM.gov Scraper: Federal Contract Opportunities Monitor](https://apify.com/fedsignals/federal-opportunities-monitor): new SAM.gov contract opportunities, filtered and deduplicated
- [USAspending Scraper: Federal Spending Trends by Category](https://apify.com/fedsignals/federal-spending-signals): where federal contract spending is growing
- [SEC Form D Scraper: New Startup Funding Rounds](https://apify.com/fedsignals/sec-form-d-monitor): new private funding rounds from SEC Form D filings
- [Building Permits Scraper: New Construction Leads by City](https://apify.com/fedsignals/building-permits-monitor): new building permits as construction leads

### Feedback

Found a bug or need a filter or source? Open an issue on the Issues tab or email **fedsignals.alerts@gmail.com**.

This Actor is not affiliated with or endorsed by the U.S. government or USAspending.gov.

# Actor input Schema

## `endsAfterDays` (type: `integer`):

Returns contracts ending at least this many days from today (start of the window).

## `endsWithinDays` (type: `integer`):

Returns contracts ending no later than this many days from today (end of the window).

## `categories` (type: `array`):

Returns only contracts in these category groups (by PSC code family). Empty = all.

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

2-6 digit NAICS codes, e.g. 541512 or 5415.

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

Product and Service Codes, full (D399) or prefixes (D3, R4, 70). Combined with Categories. Empty = all.

## `setAsides` (type: `array`):

Groups: small business, 8(a), hubzone, sdvosb, wosb, veteran-owned, indian; or raw USAspending set-aside codes such as SBA or SDVOSBC. Empty = any, including contracts with no set-aside.

## `incumbents` (type: `array`):

Company names (partial match) or UEIs, to watch specific contractors' expiring contracts. Empty = any company.

## `agencies` (type: `array`):

Top-tier awarding agencies by full name or abbreviation, e.g. Department of Veterans Affairs or VA. Unknown names fail with suggestions, free.

## `placeOfPerformanceStates` (type: `array`):

Place-of-performance states

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

Match award descriptions (any keyword).

## `minAwardAmount` (type: `integer`):

Returns only awards with at least this total value in USD.

## `activityLookbackYears` (type: `integer`):

Only awards with a transaction in this many past years.

## `onlyNew` (type: `boolean`):

On: returns only contracts not delivered before; a contract whose end date changed is returned again. Turn on for weekly schedules.

## `stateKey` (type: `string`):

Optional. Separate incremental memory per saved task. Defaults to a hash of your filters.

## `maxItems` (type: `integer`):

Maximum contracts returned (and charged) per run.

## `maxScan` (type: `integer`):

Safety cap on matches collected before sorting.

## `minRequestIntervalSec` (type: `number`):

Polite delay between API calls.

## Actor input object example

```json
{
  "endsAfterDays": 180,
  "endsWithinDays": 540,
  "categories": [
    "IT & Cyber"
  ],
  "naicsCodes": [],
  "pscCodes": [],
  "setAsides": [],
  "incumbents": [],
  "agencies": [],
  "placeOfPerformanceStates": [],
  "keywords": [],
  "minAwardAmount": 5000000,
  "activityLookbackYears": 5,
  "onlyNew": true,
  "maxItems": 10,
  "maxScan": 2000,
  "minRequestIntervalSec": 0.4
}
```

# Actor output Schema

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

Federal contracts ending in your window, with incumbent and value. One item per row; field definitions are in the dataset schema.

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

JSON summary of the run (counts scanned, pushed and skipped).

# 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 = {
    "categories": [
        "IT & Cyber"
    ],
    "minAwardAmount": 5000000,
    "onlyNew": false,
    "maxItems": 10,
    "maxScan": 2000
};

// Run the Actor and wait for it to finish
const run = await client.actor("fedsignals/federal-recompete-finder").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 = {
    "categories": ["IT & Cyber"],
    "minAwardAmount": 5000000,
    "onlyNew": False,
    "maxItems": 10,
    "maxScan": 2000,
}

# Run the Actor and wait for it to finish
run = client.actor("fedsignals/federal-recompete-finder").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 '{
  "categories": [
    "IT & Cyber"
  ],
  "minAwardAmount": 5000000,
  "onlyNew": false,
  "maxItems": 10,
  "maxScan": 2000
}' |
apify call fedsignals/federal-recompete-finder --silent --output-dataset

```

## MCP server setup

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

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/ANTLFyxzttBaHvhzK/builds/BSH5pItAiMwwmS0zu/openapi.json