# Federal Awards to Ticker Mini (`publicmoney/awards-ticker-mini`) Actor

Map US federal contract awards to the listed company that books the revenue: ticker, listed name, award value, agency, and the stated basis and confidence for every match. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/awards-ticker-mini.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 3 total users, 2 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

Federal award data names the entity that signed, not the company whose revenue line it lands on, so a subsidiary award never joins to a ticker. This Actor maps awards to the listed parent and, crucially, states why: `matchBasis` names the reason and `matchConfidence` grades it, and an award it cannot map is kept rather than quietly dropped.

### What it does

- **States the basis for every match** in `matchBasis` and grades it in `matchConfidence`, so a mapping is auditable rather than asserted.
- **Keeps the unmatched.** An award it cannot map to a listed company still comes back, so you can see the coverage instead of assuming it.
- Two modes. **Awards** returns one record per award, **rollup** totals by ticker with `awardCount` and the agencies involved.
- Covers **six award types**: contracts, grants, IDVs, loans, direct payments and other.
- Carries the **awarding agency** on every record, which is what turns a total into a story about who is buying.
- Filterable by keyword, so a run can be scoped to one programme rather than the whole feed.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Size a company's federal revenue | Use rollup mode and read `value` against `awardCount` |
| Audit a mapping before you trust it | Read `matchBasis` and `matchConfidence` on each award |
| See coverage honestly | Leave **Matched only** off and count how many awards mapped |
| Find who a programme pays | Set a keyword and group by `tickerSymbol` |
| Track an agency's spend | Group by `awardingAgency` |
| Feed a trading agent | Call the Actor over MCP and let the model ask for what it needs |

### Quick start

1. Click **Try for free**.
2. Leave **Mode** on `awards` for one record per award, or switch it to `rollup` for totals per ticker.
3. Pick the **Award types** you want: contracts, grants, IDVs, loans, direct payments or other.
4. Set **Awards to read**, and turn on **Matched only** if the unmapped awards are noise for you.
5. Click **Start**. Rows appear within seconds.
6. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `mode` | string | `awards` | `awards` returns a record per award, `rollup` totals by ticker |
| `awardTypes` | string | `contracts` | Which award type to read |
| `keyword` | string | empty | Scopes the run to awards matching this term |
| `awardsToRead` | integer | `100` | How many awards to read before mapping |
| `matchedOnly` | boolean | `false` | Drops the awards that could not be mapped to a listed company |
| `maxItems` | integer | `0` | Caps how many records are returned |

```json
{
    "mode": "awards",
    "awardTypes": "contracts",
    "awardsToRead": 100,
    "matchedOnly": false
}
```

### Output

One dataset item per award in awards mode, one per ticker in rollup mode. An award with no listed parent comes back with the mapping fields empty rather than being dropped, so coverage is visible.

| Field group | Fields |
| --- | --- |
| Mapping | `status`, `tickerSymbol`, `listedName`, `matchBasis`, `matchConfidence` |
| Award | `recipientName`, `value`, `awardingAgency`, `startDate`, `url` |
| Rollup mode | `awardCount`, `agencies`, `awardsRead` |

```json
{
    "status": "ok",
    "tickerSymbol": "LMT",
    "listedName": "Lockheed Martin Corporation",
    "recipientName": "LOCKHEED MARTIN AERONAUTICS COMPANY",
    "matchBasis": "subsidiary name match",
    "matchConfidence": "high",
    "value": 184220500.0,
    "awardingAgency": "Department of Defense",
    "startDate": "2026-07-14",
    "url": "https://www.usaspending.gov/award/CONT_AWD_0184"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~awards-ticker-mini/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "awards", "awardTypes": "contracts", "awardsToRead": 100, "matchedOnly": false}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/awards-ticker-mini").call(run_input={"mode": "awards", "awardTypes": "contracts", "awardsToRead": 100, "matchedOnly": false})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["value"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/awards-ticker-mini"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Award record | $0.01 | $0.004 |
| Actor start | $0.00005 per GB | Same |

Two things are charged. The **award record** above is this Actor's own event. On top of that it runs the USAspending Actor as a **child run on your account**, which charges its own per-record price and will not appear in this Actor's usage total. **Awards to read** is the lever. A record that returned no data is never charged.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| Most awards have no ticker | Most federal recipients are not listed companies. That is the real coverage, which is why unmatched awards are kept rather than hidden. |
| A mapping looks wrong | Read `matchBasis`. It names the reason, so you can reject the ones whose basis you do not accept, and `matchConfidence` grades it. |
| Rollup totals differ from a company's reported revenue | They should. This is federal award value, not booked revenue, and the timing and the entity boundary both differ. |
| The run costs more than the record price suggests | The USAspending child Actor charges its own per-record price on your account, outside this Actor's usage total. |
| Fewer records than **Awards to read** | The cap applies to awards read before mapping, and **Matched only** then drops the unmapped ones. |

### FAQ

#### Why do federal awards not already carry a ticker?

Because the award names the entity that signed the contract, which is usually a subsidiary or a division. Joining that to a listed parent is the work, and it is the reason this Actor exists.

#### How do I know a mapping is right?

You read `matchBasis`, which names why the match was made, and `matchConfidence`, which grades it. Nothing is asserted without a stated reason.

#### Why keep the awards that did not map?

Because dropping them hides the coverage. An answer that silently covers 30 percent of the feed looks the same as one that covers 90, and you would have no way to tell.

#### Is this the same as a company's reported revenue?

No. It is federal award value, which differs from booked revenue in timing, in entity boundary and in whether the award is ever fully exercised.

#### Why is it priced above the single-source Actors?

One record fans out into a child run against the USAspending Actor, which charges its own per-record price on your account.

#### Do I need a USAspending API key?

No. You need an Apify token to call the Actor over the API. No USAspending credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape USAspending?

This Actor reads public USAspending data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

### Changelog

- **0.0.1** First release. Awards and rollup modes with stated match basis.

### Feedback

Found a field USAspending publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

## `mode` (type: `string`):

Awards returns every award read, matched or not, with the basis for each match. Rollup returns one row per ticker: what that company won across the awards read, which is the shape to line up against revenue.

## `awardTypes` (type: `string`):

Which USAspending award family to read.

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

Narrow the awards to those matching a keyword. Leave empty for the largest awards by value.

## `awardsToRead` (type: `integer`):

How many awards to read before matching.

## `matchedOnly` (type: `boolean`):

Drop awards with no listed parent. Off by default: an unmatched award is still a fact about federal spending, and dropping it hides how much of the total is unlisted.

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

Stop after this many charged records. 0 means no cap.

## Actor input object example

```json
{
  "mode": "awards",
  "awardTypes": "contracts",
  "keyword": "",
  "awardsToRead": 100,
  "matchedOnly": false,
  "maxItems": 0
}
```

# Actor output Schema

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

One item per requested input, in the default dataset.

# 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 = {
    "mode": "awards",
    "awardTypes": "contracts",
    "keyword": "",
    "awardsToRead": 100,
    "matchedOnly": false,
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/awards-ticker-mini").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 = {
    "mode": "awards",
    "awardTypes": "contracts",
    "keyword": "",
    "awardsToRead": 100,
    "matchedOnly": False,
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/awards-ticker-mini").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 '{
  "mode": "awards",
  "awardTypes": "contracts",
  "keyword": "",
  "awardsToRead": 100,
  "matchedOnly": false,
  "maxItems": 0
}' |
apify call publicmoney/awards-ticker-mini --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/awards-ticker-mini"
        }
    }
}

```

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/hbGH33wDSN1VXCoiQ/builds/1PMDXibKda9xtnH6N/openapi.json