# SBIR/STTR: 4,400+ Federal R\&D Grants by Agency & Phase (`andrew_avina/sbir-intelligence-mcp`) Actor

Search every SBIR/STTR award by agency, company, topic, phase, keyword. DOD, NIH, NSF, DOE, NASA, USDA + 5 more. Returns amount, PI, institution, abstract. Use cases: gov contractor BD, IP research, R\&D intel. MCP-native. Source: SBIR.gov.

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

## Pricing

from $0.50 / 1,000 results

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

## sbir-intelligence-mcp

> **The $4B/year federal innovation program, searchable by AI.**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/actors/sbir-intelligence-mcp)
[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-blue)](https://modelcontextprotocol.io)
[![Data Source](https://img.shields.io/badge/Data-USASpending.gov-navy)](https://www.usaspending.gov)
[![License](https://img.shields.io/badge/License-Apache%202.0-lightgrey)](LICENSE)
[![SBIR Program](https://img.shields.io/badge/SBIR%2FSTTR-$4B%2Fyear-gold)](https://www.sbir.gov)

---

### What Is This?

The Small Business Innovation Research (SBIR) and Small Business Technology Transfer (STTR) programs distribute over **$4 billion per year** to American small businesses doing federally-funded R&D. Every award is public record — but the official search interface is antiquated, slow, and completely unusable by AI systems.

**sbir-intelligence-mcp** is a Model Context Protocol (MCP) actor that exposes the full SBIR/STTR award database — sourced from USASpending.gov — as structured, AI-queryable tools. Claude, GPT-4, Gemini, or any MCP-compatible AI assistant can now search, filter, analyze, and summarize federal innovation awards in natural language.

Phase I awards (proof-of-concept, up to $275K), Phase II awards (prototype development, up to $1.85M), and Phase III (commercialization) are all searchable. Filter by agency, keyword, award amount, date range, state, or company name. Get structured JSON results you can pipe directly into analysis workflows.

This is not a scraper. All data is sourced from the official USASpending.gov public API — the same authoritative source used by federal procurement officers and Congressional oversight staff.

---

### Who Uses This?

| User Type | Pain They Have Today | How This Solves It |
|---|---|---|
| **GovCon BD Teams** | Manual SBIR research takes hours per competitor | Search competitors' award history in seconds; identify white space |
| **Venture Capital Firms** | Deep-tech deal flow from gov R&D is invisible | Find $1M+ Phase II companies before they raise VC rounds |
| **Grant Writers & Consultants** | Benchmarking prior awards requires manual USASpending navigation | Pull 50 comparable awards in one query to calibrate proposal budgets |
| **Investigative Journalists** | Tracking federal R&D spending by agency/topic is painful | Cross-agency keyword searches with amount filtering |
| **University Tech Transfer Offices** | Finding STTR partner companies requires manual research | Filter STTR awards by technology area and institutional partner |
| **M&A Analysts** | Assessing a target company's government contract history | Pull full award history by company name or EIN |
| **Policy Researchers** | Tracking how R&D investment shifts by administration | Time-series queries across agencies and technology domains |
| **Defense Contractors** | Identifying small business subcontract candidates | Search by agency + tech area + Phase to find proven performers |

---

### Feature Overview

| Feature | Detail |
|---|---|
| **Phase I Search** | Awards up to $275K; proof-of-concept stage |
| **Phase II Search** | Awards up to $1.85M; prototype development stage |
| **Phase III Search** | Commercialization awards; no statutory cap |
| **Agency Filter** | All 11 participating agencies: DoD, NIH, NSF, NASA, DOE, EPA, USDA, DHS, ED, HHS, DOT |
| **Keyword Search** | Full-text search across award titles and abstracts |
| **Amount Range** | Min/max dollar filter |
| **Date Range** | Award start and end date filtering |
| **State Filter** | Filter by awardee state |
| **Company Name Search** | Exact or fuzzy company name matching |
| **Structured Output** | JSON with company name, EIN, award amount, agency, phase, abstract, DUNS |
| **Batch Mode** | Process hundreds of queries via Apify dataset input |
| **MCP Mode** | Real-time tool calls from any MCP-compatible AI assistant |
| **Result Pagination** | Up to 1,000 results per query with cursor support |

---

### Quick Start

#### MCP Mode (Claude Desktop / AI Assistants)

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "sbir-intelligence": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/mcp-client",
        "--actor-id",
        "your-username/sbir-intelligence-mcp",
        "--token",
        "YOUR_APIFY_TOKEN"
      ]
    }
  }
}
````

Then ask Claude:

> "Find all Phase II SBIR awards from NIH related to CRISPR gene editing since 2020, show me the companies and award amounts."

#### Batch Mode (Apify Platform)

```json
{
  "mode": "batch",
  "queries": [
    {
      "keyword": "machine learning autonomous systems",
      "agency": "DoD",
      "phase": "II",
      "minAmount": 500000,
      "maxAmount": 1850000,
      "dateFrom": "2022-01-01",
      "dateTo": "2024-12-31"
    }
  ]
}
```

#### API Mode

```bash
curl -X POST https://api.apify.com/v2/acts/your-username~sbir-intelligence-mcp/run-sync \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "keyword": "quantum computing",
    "agency": "NSF",
    "phase": "I",
    "maxResults": 50
  }'
```

***

### MCP Tools Reference

#### `search_sbir_awards`

Search the SBIR/STTR award database with flexible filters.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `keyword` | string | No | Full-text search across title and abstract |
| `agency` | string | No | Agency code: `DoD`, `NIH`, `NSF`, `NASA`, `DOE`, `EPA`, `USDA`, `DHS`, `ED`, `HHS`, `DOT` |
| `phase` | string | No | `I`, `II`, or `III` |
| `minAmount` | number | No | Minimum award amount in USD |
| `maxAmount` | number | No | Maximum award amount in USD |
| `dateFrom` | string | No | Award start date (YYYY-MM-DD) |
| `dateTo` | string | No | Award end date (YYYY-MM-DD) |
| `state` | string | No | Two-letter state code (e.g., `CA`, `TX`) |
| `companyName` | string | No | Company name (partial match supported) |
| `maxResults` | integer | No | Maximum results to return (default: 50, max: 1000) |

**Response fields:**

```json
{
  "awards": [
    {
      "awardId": "2023-NIH-12345",
      "companyName": "Quantum Genomics Inc.",
      "ein": "84-1234567",
      "dunsNumber": "123456789",
      "state": "CA",
      "city": "San Diego",
      "agency": "NIH",
      "phase": "II",
      "awardAmount": 1750000,
      "awardDate": "2023-03-15",
      "projectEndDate": "2025-03-14",
      "title": "Novel CRISPR Delivery Mechanism for Rare Disease Targets",
      "abstract": "This Phase II award continues development of...",
      "topicCode": "NIAID-003",
      "solicitationYear": 2022,
      "programOfficer": "Dr. Jane Smith"
    }
  ],
  "totalCount": 847,
  "queryMetadata": {
    "executedAt": "2024-01-15T14:23:11Z",
    "dataSource": "USASpending.gov",
    "apiVersion": "v2"
  }
}
```

#### `get_company_award_history`

Retrieve complete SBIR/STTR award history for a specific company.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `companyName` | string | Yes | Company name to look up |
| `ein` | string | No | EIN for exact matching |
| `includePhases` | array | No | Which phases to include (default: all) |

#### `get_agency_statistics`

Get aggregate statistics for an agency's SBIR/STTR program.

**Parameters:**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `agency` | string | Yes | Agency code |
| `year` | integer | No | Fiscal year (default: current) |
| `breakdown` | string | No | `state`, `phase`, `topic`, or `size` |

***

### Use Case Recipes

#### Recipe 1: VC Deal Flow — Find Pre-VC Deep-Tech Companies

**The insight:** Phase II SBIR companies ($750Kâ€“$1.85M) have federally validated technology but are often pre-revenue and invisible to traditional VC deal flow.

**Query sequence:**

```
1. search_sbir_awards(agency="NIH", phase="II", keyword="AI diagnostics", dateFrom="2022-01-01", minAmount=1000000)
2. For each result: get_company_award_history(companyName=result.companyName)
3. Flag companies with Phase I â†’ Phase II progression (validated tech) but no Phase III (pre-commercialization)
```

**Claude prompt to use:**

> "Search for NIH Phase II SBIR awards in AI diagnostics since 2022 with awards over $1M. For the top 10 companies, pull their full award history and tell me which ones have never received Phase III funding — those are my target companies."

#### Recipe 2: GovCon Competitive Intelligence

**The insight:** Your competitors' SBIR award abstracts are public record and contain their entire technology roadmap.

**Query:**

```
search_sbir_awards(companyName="Palantir", agency="DoD", phase="II")
```

**Claude prompt:**

> "Pull all DoD SBIR Phase II awards for the following companies: \[list competitors]. Summarize the technology areas each is investing in and flag any overlaps with our current product roadmap."

#### Recipe 3: Grant Writer Budget Benchmarking

**The insight:** Knowing the range of prior awards for your technology area lets you calibrate your budget narrative precisely.

**Query:**

```
search_sbir_awards(keyword="autonomous underwater vehicle", phase="II", agency="DoD", dateFrom="2020-01-01")
```

**Claude prompt:**

> "I'm writing a Phase II SBIR proposal for an autonomous underwater vehicle for mine detection. Pull all similar awards from DoD since 2020 and give me: the median award amount, the range, the most common budget period, and the top 3 program offices awarding in this space."

#### Recipe 4: Journalist — Track Federal AI Investment

**Query:**

```
search_sbir_awards(keyword="large language model", dateFrom="2022-01-01", maxResults=500)
```

**Claude prompt:**

> "Search all SBIR/STTR agencies for awards mentioning 'large language model' or 'LLM' since 2022. Show me total dollars awarded by agency, year-over-year growth, and the top 10 award recipients by total dollars."

#### Recipe 5: University Tech Transfer — STTR Partner Discovery

**Query:**

```
search_sbir_awards(keyword="mRNA vaccine delivery", phase="I", dateFrom="2021-01-01", maxResults=100)
```

**Claude prompt:**

> "Find STTR Phase I awards related to mRNA vaccine delivery. STTR requires a research institution partner — I need to find small companies actively partnering with universities in this space so I can pitch our tech transfer office as a partner."

***

### Claude Desktop Configuration

Full configuration block for `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "sbir-intelligence": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/mcp-client",
        "--actor-id",
        "your-username/sbir-intelligence-mcp",
        "--token",
        "apify_api_XXXXXXXXXXXXXXXXXXXX"
      ],
      "env": {
        "APIFY_TOKEN": "apify_api_XXXXXXXXXXXXXXXXXXXX"
      }
    }
  }
}
```

**Verification:** After restarting Claude Desktop, ask: "What SBIR tools do you have available?" Claude should list `search_sbir_awards`, `get_company_award_history`, and `get_agency_statistics`.

***

### Input Schema (Full)

```json
{
  "mode": {
    "type": "string",
    "enum": ["search", "company_history", "agency_stats", "batch"],
    "description": "Operating mode",
    "default": "search"
  },
  "keyword": {
    "type": "string",
    "description": "Full-text search term for award title and abstract"
  },
  "agency": {
    "type": "string",
    "enum": ["DoD", "NIH", "NSF", "NASA", "DOE", "EPA", "USDA", "DHS", "ED", "HHS", "DOT"],
    "description": "Participating SBIR agency"
  },
  "phase": {
    "type": "string",
    "enum": ["I", "II", "III"],
    "description": "SBIR/STTR phase"
  },
  "minAmount": {
    "type": "number",
    "description": "Minimum award amount in USD",
    "minimum": 0
  },
  "maxAmount": {
    "type": "number",
    "description": "Maximum award amount in USD",
    "maximum": 10000000
  },
  "dateFrom": {
    "type": "string",
    "format": "date",
    "description": "Award date range start (YYYY-MM-DD)"
  },
  "dateTo": {
    "type": "string",
    "format": "date",
    "description": "Award date range end (YYYY-MM-DD)"
  },
  "state": {
    "type": "string",
    "minLength": 2,
    "maxLength": 2,
    "description": "Two-letter US state code"
  },
  "companyName": {
    "type": "string",
    "description": "Company name (partial match supported)"
  },
  "maxResults": {
    "type": "integer",
    "minimum": 1,
    "maximum": 1000,
    "default": 50,
    "description": "Maximum number of results to return"
  },
  "queries": {
    "type": "array",
    "description": "Array of query objects for batch mode",
    "items": {
      "type": "object"
    }
  }
}
```

***

### Pricing & Usage

| Tier | Price | Includes |
|---|---|---|
| **Free** | $0 | 100 results/month |
| **Starter** | $9/month | 5,000 results/month |
| **Professional** | $49/month | 50,000 results/month + batch |
| **Enterprise** | $199/month | Unlimited + dedicated support |

All tiers include MCP compatibility. Batch mode available on Professional and above.

***

### Data Source & Freshness

- **Primary source:** USASpending.gov Award Search API (v2)
- **Data authority:** US Treasury Department / FPDS
- **Update frequency:** Awards typically appear within 30â€“90 days of execution
- **Historical coverage:** Awards dating back to 1983
- **Total awards in database:** 200,000+ active and historical records

***

### Technical Notes

- Rate limiting: USASpending.gov enforces per-IP rate limits; this actor implements exponential backoff and request queuing automatically
- Abstract text is included for all awards where available (some older records have redacted abstracts)
- STTR awards are included in all queries unless explicitly filtered out
- The `dunsNumber` field is being phased out in favor of UEI (Unique Entity Identifier) by SAM.gov; both are returned where available
- SSL verification is enforced; no data is cached beyond the actor run lifetime

***

### Support & Issues

- **GitHub Issues:** [github.com/your-username/sbir-intelligence-mcp](https://github.com/your-username/sbir-intelligence-mcp)
- **Apify Discord:** #actor-support channel
- **Email:** support@your-domain.com
- **Response SLA:** Business day replies for Professional+; best-effort for free tier

***

*Data sourced from USASpending.gov. Not affiliated with the US government or SBA SBIR program.*

# Actor input Schema

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

Search keyword matched against award title and abstract (e.g. 'quantum computing', 'AI')

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

Filter by agency name (e.g. 'NSF', 'NIH', 'DOE', 'NASA', 'Army', 'Air Force')

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

Only return awards with amount >= this value

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

Only return awards with amount <= this value (0 = no limit)

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

Maximum number of awards to return (max 500)

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

When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this to connect AI assistants directly to SBIR data.

## Actor input object example

```json
{
  "query": "",
  "agency": "",
  "minAmount": 0,
  "maxAmount": 0,
  "limit": 50,
  "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/sbir-intelligence-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/sbir-intelligence-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/sbir-intelligence-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SBIR/STTR: 4,400+ Federal R&D Grants by Agency & Phase",
        "description": "Search every SBIR/STTR award by agency, company, topic, phase, keyword. DOD, NIH, NSF, DOE, NASA, USDA + 5 more. Returns amount, PI, institution, abstract. Use cases: gov contractor BD, IP research, R&D intel. MCP-native. Source: SBIR.gov.",
        "version": "0.0",
        "x-build-id": "6WfYn8ybeRhWbLHvR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/andrew_avina~sbir-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-andrew_avina-sbir-intelligence-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~sbir-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-andrew_avina-sbir-intelligence-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~sbir-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-andrew_avina-sbir-intelligence-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 award title and abstract (e.g. 'quantum computing', 'AI')",
                        "default": ""
                    },
                    "agency": {
                        "title": "Funding Agency",
                        "type": "string",
                        "description": "Filter by agency name (e.g. 'NSF', 'NIH', 'DOE', 'NASA', 'Army', 'Air Force')",
                        "default": ""
                    },
                    "minAmount": {
                        "title": "Minimum Award Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return awards with amount >= this value",
                        "default": 0
                    },
                    "maxAmount": {
                        "title": "Maximum Award Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return awards with amount <= this value (0 = no limit)",
                        "default": 0
                    },
                    "limit": {
                        "title": "Result Limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of awards to return (max 500)",
                        "default": 50
                    },
                    "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 to connect AI assistants directly to SBIR data.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
