# USAspending Federal Award Leads (`orbiscribe/usaspending-award-leads`) Actor

Find companies that already won related US federal contracts and grants using the official USAspending.gov public API.

- **URL**: https://apify.com/orbiscribe/usaspending-award-leads.md
- **Developed by:** [Orbiscribe Labs](https://apify.com/orbiscribe) (community)
- **Categories:** Business, Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 33.3% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 award 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/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

Find companies that already won related US federal contracts and grants.
USAspending Federal Award Leads searches the official USAspending.gov public API
and returns recent award winners by keyword, agency, award type, amount, and
date range.

Use it to build prospect lists of incumbent vendors, partner candidates,
competitors, agency spending patterns, and market maps for government
contracting.

### What does this USAspending scraper do?

Award history tells you who already buys, who wins, which agencies spend, and
what contract language they use. This Actor turns USAspending award search into
a clean Apify dataset with recipient names, UEIs, award IDs, award amounts,
NAICS/PSC fields, agencies, dates, descriptions, source URLs, and lead scores.

It uses the official API, requires no login, and writes one dataset row per
award lead.

The Actor also writes key-value outputs for scheduled workflows:

- `RUN_SUMMARY`: counts, inputs, and errors
- `AWARD_LEAD_EXPORT`: all emitted award lead records
- `BUYER_BRIEF`: a short Markdown brief with highest-value leads
- `SLACK_ALERTS`: compact alert objects for webhook or chat workflows

### What data can you extract?

| Field | Description |
| --- | --- |
| `recipientName` | Company or organization that received the award |
| `recipientUei` | Recipient UEI when available |
| `awardAmount` | Reported award amount |
| `awardId` | USAspending award identifier |
| `awardType` | Contract, grant, loan, or other award type |
| `awardingAgency` | Agency that issued the award |
| `fundingAgency` | Funding agency when different |
| `startDate` / `endDate` | Award period dates |
| `description` | Award description text |
| `naics` | NAICS code or label |
| `psc` | Product Service Code |
| `leadScore` | Simple score for sales or market-research triage |
| `sourceUrl` | Link to the USAspending record |

### Quick start

1. Enter keywords such as `software`, `cybersecurity`, `training`, or `data platform`.
2. Set a recent date window.
3. Choose contract and/or grant award groups.
4. Set `minAwardAmount` to remove tiny awards.
5. Start with `maxResults: 25`, review the winners, then schedule recurring runs.

### Input example

```json
{
  "keywords": ["software", "cybersecurity", "data platform"],
  "agencyNames": [],
  "awardTypeGroups": ["contracts", "grants"],
  "startDate": "2025-10-01",
  "endDate": "2026-05-10",
  "minAwardAmount": 100000,
  "maxResults": 25,
  "dedupeRecipients": false,
  "includeRawData": false
}
````

### Output example

```json
{
  "source": "USAspending.gov",
  "searchKeyword": "software",
  "awardId": "DEMO-2026-C-0001",
  "recipientName": "Example Systems LLC",
  "recipientUei": "DEMOUEI12345",
  "awardAmount": 750000,
  "awardType": "Definitive Contract",
  "awardingAgency": "Department of Demo",
  "startDate": "2026-01-15",
  "endDate": "2027-01-14",
  "description": "Software modernization and data platform support services.",
  "naics": "541511",
  "psc": "DA01",
  "leadScore": 75,
  "leadReasons": [
    "award is at least $100K",
    "has recipient UEI",
    "has NAICS or PSC classification"
  ],
  "sourceUrl": "https://www.usaspending.gov/"
}
```

### Pricing

This Actor uses pay-per-event pricing. Dry-run examples are not charged. Apify free-plan users get the first 25 award lead records without this Actor's custom event charge; after that, normal pay-per-event pricing and the user's run spending limit apply.

| Event | Price | What counts |
| --- | --- | --- |
| `award-lead` | `$0.004` | One USAspending award lead written to the dataset |

That is `$4 per 1,000` emitted award records, plus normal Apify platform usage.
Use `maxResults`, `minAwardAmount`, and date filters to control cost.

### Common use cases

- Build lists of recent award winners in a category.
- Track agencies buying software, services, equipment, or research.
- Find incumbent contractors before a recompete.
- Monitor competitors and partner candidates by NAICS or PSC.
- Feed award records into CRM enrichment, spreadsheets, or market maps.

### Limits and compliance

This Actor uses public USAspending.gov data. Award history is not an open
solicitation. Treat the output as market intelligence and verify important
records on USAspending.gov before acting.

# Actor input Schema

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

Keyword searches against federal award records.

## `agencyNames` (type: `array`):

Optional exact top-tier awarding agency names, for example Department of Defense.

## `awardTypeGroups` (type: `array`):

Federal award categories to include.

## `startDate` (type: `string`):

Start date for award search in YYYY-MM-DD format.

## `endDate` (type: `string`):

End date for award search in YYYY-MM-DD format.

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

Only include awards at or above this amount.

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

Maximum award leads to emit.

## `dedupeRecipients` (type: `boolean`):

Return only the largest award per recipient and aggregate award counts.

## `includeRawData` (type: `boolean`):

Attach the raw USAspending API row to each dataset item.

## `dryRun` (type: `boolean`):

Emit one deterministic sample item without calling USAspending.gov.

## Actor input object example

```json
{
  "keywords": [
    "software",
    "cybersecurity",
    "data"
  ],
  "agencyNames": [],
  "awardTypeGroups": [
    "contracts",
    "grants"
  ],
  "startDate": "2025-10-01",
  "endDate": "2026-05-10",
  "minAwardAmount": 100000,
  "maxResults": 100,
  "dedupeRecipients": false,
  "includeRawData": false,
  "dryRun": false
}
```

# 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 = {
    "keywords": [
        "software",
        "cybersecurity",
        "data"
    ],
    "agencyNames": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("orbiscribe/usaspending-award-leads").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 = {
    "keywords": [
        "software",
        "cybersecurity",
        "data",
    ],
    "agencyNames": [],
}

# Run the Actor and wait for it to finish
run = client.actor("orbiscribe/usaspending-award-leads").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 '{
  "keywords": [
    "software",
    "cybersecurity",
    "data"
  ],
  "agencyNames": []
}' |
apify call orbiscribe/usaspending-award-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USAspending Federal Award Leads",
        "description": "Find companies that already won related US federal contracts and grants using the official USAspending.gov public API.",
        "version": "0.1",
        "x-build-id": "vHtbhWwtuPZMjCdPS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/orbiscribe~usaspending-award-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-orbiscribe-usaspending-award-leads",
                "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/orbiscribe~usaspending-award-leads/runs": {
            "post": {
                "operationId": "runs-sync-orbiscribe-usaspending-award-leads",
                "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/orbiscribe~usaspending-award-leads/run-sync": {
            "post": {
                "operationId": "run-sync-orbiscribe-usaspending-award-leads",
                "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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keyword searches against federal award records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencyNames": {
                        "title": "Awarding agencies",
                        "type": "array",
                        "description": "Optional exact top-tier awarding agency names, for example Department of Defense.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "awardTypeGroups": {
                        "title": "Award type groups",
                        "type": "array",
                        "description": "Federal award categories to include.",
                        "default": [
                            "contracts",
                            "grants"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Start date for award search in YYYY-MM-DD format.",
                        "default": "2025-10-01"
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "End date for award search in YYYY-MM-DD format.",
                        "default": "2026-05-10"
                    },
                    "minAwardAmount": {
                        "title": "Minimum award amount",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include awards at or above this amount.",
                        "default": 100000
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum award leads to emit.",
                        "default": 100
                    },
                    "dedupeRecipients": {
                        "title": "Dedupe recipients",
                        "type": "boolean",
                        "description": "Return only the largest award per recipient and aggregate award counts.",
                        "default": false
                    },
                    "includeRawData": {
                        "title": "Include raw API data",
                        "type": "boolean",
                        "description": "Attach the raw USAspending API row to each dataset item.",
                        "default": false
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Emit one deterministic sample item without calling USAspending.gov.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
