# SAM.gov Contract Opportunities Monitor (`fetch_cat/sam-gov-contract-opportunities-monitor`) Actor

Monitor US federal contract opportunities from SAM.gov with filters, normalized fields, direct notice links, and relevance scoring.

- **URL**: https://apify.com/fetch\_cat/sam-gov-contract-opportunities-monitor.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 opportunity saveds

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/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

## SAM.gov Contract Opportunities Monitor

Find and monitor US federal contract opportunities from SAM.gov with keyword, agency, date, NAICS, PSC, notice type, and active-status filters.

Use this Actor to turn public federal procurement notices into a clean dataset for capture management, bid/no-bid triage, sales prospecting, research, and recurring opportunity monitoring.

### What does SAM.gov Contract Opportunities Monitor do?

This Actor searches US federal contract opportunity notices and saves matching opportunities as structured records.

It is designed for repeat monitoring workflows where you need clean rows, useful filters, and direct links back to the original notice.

You can search by capability terms such as cybersecurity, construction, janitorial, cloud, medical supplies, staffing, training, or logistics.

Each saved row includes opportunity title, solicitation number, notice type, agency hierarchy, dates, status, summary, direct SAM.gov link, relevance score, and matched keywords when available.

### Who is it for?

- 🏛️ Government contractors tracking new federal opportunities
- 🎯 Capture managers building a qualified pursuit pipeline
- 📈 Sales teams looking for public-sector leads
- 🧾 Proposal consultants monitoring opportunities for clients
- 🔍 Market researchers analyzing agency demand
- 🧠 Competitive intelligence teams following procurement trends
- 🏗️ Vendors that need fast filtering by agency, NAICS, PSC, or notice type

### Why use this Actor?

SAM.gov is the official source, but recurring monitoring can be time-consuming when teams need exports, filters, automation, and repeatable searches.

This Actor gives you a clean dataset that can be exported, joined with CRM records, sent to alerts, or processed by your own scoring workflow.

### Typical use cases

- Track new opportunities for a capability area every morning
- Monitor a target agency or office
- Build a weekly capture pipeline spreadsheet
- Watch sources-sought and solicitation notices separately
- Feed opportunity records into a CRM or BI dashboard
- Research federal demand for a NAICS or PSC code
- Send new matching opportunities to Slack, email, or a database

### What data can you extract?

| Field | Description |
| --- | --- |
| `noticeId` | SAM.gov notice identifier |
| `solicitationNumber` | Solicitation or reference number |
| `title` | Opportunity title |
| `typeCode` | SAM.gov notice type code |
| `typeLabel` | Human-readable notice type |
| `agency` | Department name |
| `subAgency` | Agency name |
| `office` | Contracting office when available |
| `postedDate` | Original posted date |
| `modifiedDate` | Most recent modification date |
| `responseDeadline` | Response deadline when available |
| `isActive` | Whether the notice is currently active |
| `isCanceled` | Whether the notice is canceled |
| `naics` | NAICS codes when available |
| `psc` | Product Service Codes when available |
| `setAside` | Set-aside information when available |
| `placeOfPerformance` | Place of performance when available |
| `summary` | Cleaned short description |
| `descriptionText` | Optional full cleaned description |
| `uiUrl` | Direct public SAM.gov notice URL |
| `sourceUrl` | Source search URL used for the record |
| `relevanceScore` | Search relevance score normalized for sorting |
| `matchedKeywords` | Input keywords matched in the record text |
| `estimatedValue` | Estimated value when exposed |

### How much does it cost to monitor SAM.gov contract opportunities?

The Actor uses pay-per-event pricing.

There is a small $0.005 run-start event and a per-opportunity event for each saved dataset row.

| Plan tier | Price per saved opportunity | Approx. cost for 1,000 opportunities |
| --- | ---: | ---: |
| Free | $0.000115 | $0.115 |
| Starter / Bronze | $0.0001 | $0.100 |
| Silver | $0.000078 | $0.078 |
| Gold | $0.00006 | $0.060 |
| Platinum | $0.00004 | $0.040 |
| Diamond | $0.000028 | $0.028 |

For early testing, start with `maxItems` between 10 and 50.

For recurring monitoring, choose the smallest keyword and filter set that captures the opportunities your team actually reviews.

### Quick start

1. Open the Actor on Apify.
2. Enter one or more keywords.
3. Keep `activeOnly` enabled if you only want open opportunities.
4. Set `maxItems` to the maximum number of records you want.
5. Optionally add agency, NAICS, PSC, date, or notice type filters.
6. Run the Actor.
7. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

#### Keywords

Use one or more search terms.

Examples:

- `cybersecurity`
- `construction`
- `cloud migration`
- `medical supplies`
- `janitorial services`

#### Posted date range

Use `postedFrom` and `postedTo` to keep only opportunities posted in a specific date window.

#### Notice types

Use notice type codes or labels to focus on specific procurement stages.

Examples:

- `r` for Sources Sought
- `p` for Presolicitation
- `o` for Solicitation
- `k` for Combined Synopsis/Solicitation

#### Agency filter

Use agency text to keep records whose department, agency, or office contains your target phrase.

Examples:

- `Department of Defense`
- `Veterans Affairs`
- `General Services Administration`

#### NAICS and PSC filters

Use these when your capture process is code-driven.

Examples:

- NAICS `541512`
- NAICS `236220`
- PSC `D399`
- PSC `R499`

#### Active opportunities only

When enabled, inactive or closed notices are skipped.

Some searches may require scanning many records to find active notices.

#### Include full description

Enable this when you need long notice descriptions in the dataset.

Keep it disabled when you only need short summaries and smaller exports.

### Example input

```json
{
  "keywords": ["cybersecurity", "cloud migration"],
  "activeOnly": true,
  "maxItems": 50,
  "sort": "modifiedDate",
  "agency": "Department of Defense",
  "includeDescription": false
}
````

### Example output

```json
{
  "noticeId": "a63176dfde62490abfbc1ddce723754d",
  "solicitationNumber": "W912HNA044275",
  "title": "Construction and Alteration of Polygraph Office at Ft. Gordon",
  "typeLabel": "Sources Sought",
  "agency": "DEPT OF DEFENSE",
  "subAgency": "DEPT OF THE ARMY",
  "office": "W074 ENDIST SAVANNAH",
  "postedDate": "2026-06-04T19:10:01+00:00",
  "responseDeadline": "2026-06-01T11:00:00-04:00",
  "isActive": false,
  "summary": "As of 4 June 2026, this Sources Sought Notice is hereby concluded...",
  "uiUrl": "https://sam.gov/opp/a63176dfde62490abfbc1ddce723754d/view",
  "relevanceScore": 100,
  "matchedKeywords": [],
  "estimatedValue": null
}
```

### Tips for better results

- Use precise capability keywords instead of very broad words.
- Combine keyword searches with agency or NAICS filters for cleaner exports.
- Keep `maxItems` low while testing a new search.
- Use recurring Apify schedules for daily or weekly monitoring.
- Export to CSV when sharing with proposal teams.
- Enable full descriptions only when you need long-form text analysis.

### Monitoring workflows

You can schedule the Actor to run every day and compare new dataset rows against your previous run.

Common workflow:

1. Run a daily keyword search.
2. Export only new notice IDs.
3. Send selected rows to a CRM, spreadsheet, Slack channel, or email digest.
4. Assign capture owners to high-fit opportunities.

### Integrations

Use Apify integrations to connect results to your workflow.

- Google Sheets for opportunity trackers
- Make or Zapier for alerts
- Slack for team notifications
- Airtable for capture pipelines
- Webhooks for custom apps
- BI tools for procurement trend dashboards

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/sam-gov-contract-opportunities-monitor').call({
  keywords: ['cybersecurity'],
  activeOnly: true,
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/sam-gov-contract-opportunities-monitor').call(run_input={
    'keywords': ['cybersecurity'],
    'activeOnly': True,
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~sam-gov-contract-opportunities-monitor/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["cybersecurity"],"activeOnly":true,"maxItems":25}'
```

### MCP usage

Use the Apify MCP Server to run this Actor from AI tools that support MCP.

MCP URL format:

```text
https://mcp.apify.com/?tools=fetch_cat/sam-gov-contract-opportunities-monitor
```

Claude Code setup:

```bash
claude mcp add apify-sam-gov-contracts "https://mcp.apify.com/?tools=fetch_cat/sam-gov-contract-opportunities-monitor"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-sam-gov-contracts": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/sam-gov-contract-opportunities-monitor"
    }
  }
}
```

Example prompts:

- "Find active cybersecurity opportunities from SAM.gov and summarize the top 10."
- "Run a SAM.gov search for construction opportunities and group results by agency."
- "Monitor cloud migration solicitations and prepare a bid/no-bid shortlist."

### Data quality notes

SAM.gov records vary by notice and agency.

Some fields are not present on every record.

Estimated value, place of performance, set-aside, NAICS, and PSC fields may be missing for some opportunities.

The direct SAM.gov URL is included so your team can review the official notice before acting.

### Legality and ethical use

This Actor works with public government procurement opportunity information.

Always review the official notice on SAM.gov before making business decisions.

Respect applicable procurement rules, deadlines, and agency instructions.

Do not use exported data for spam or misleading outreach.

### Troubleshooting

#### Why did I get fewer results than `maxItems`?

Your filters may be too narrow, active-only filtering may skip many closed records, or the search may have fewer matching opportunities.

Try disabling `activeOnly`, broadening keywords, or removing agency/code filters.

#### Why is estimated value empty?

Many notices do not expose an estimated value in the searchable record.

Use the official SAM.gov link for final review.

#### Why are NAICS or PSC arrays empty?

Some records do not include these codes in the search result.

Try a broader search or inspect the official notice details.

### FAQ

#### Can I monitor multiple keywords at once?

Yes. Add multiple keywords and the Actor will collect matching opportunities across them while deduplicating by notice ID.

#### Can I export to Excel?

Yes. Apify datasets can be exported as Excel, CSV, JSON, XML, RSS, or HTML.

#### Can I run this every day?

Yes. Use Apify schedules to run the Actor daily or weekly.

#### Does this submit bids or contact agencies?

No. It only collects opportunity records for monitoring and analysis.

#### Is this US-only?

Yes. Version 1 focuses on US federal opportunities from SAM.gov.

### Related Apify Actors

Explore related FetchCat actors for lead generation, market research, and public data workflows:

- [Google Maps Reviews Scraper](https://apify.com/fetch_cat/google-maps-reviews-scraper) — monitor local business reputation and customer feedback.
- [Shopify Products Scraper](https://apify.com/fetch_cat/shopify-products-scraper) — collect product catalog data for market and competitor research.
- [Craigslist Search Scraper](https://apify.com/fetch_cat/craigslist-search-scraper) — track classified listings and local-market opportunities.

### Changelog

#### 0.1

Initial version with keyword search, filters, normalized opportunity output, direct SAM.gov links, summaries, and relevance scoring.

# Actor input Schema

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

Opportunity search terms. Use product, service, agency mission, or capability keywords such as cybersecurity, construction, janitorial, cloud, or medical supplies.

## `postedFrom` (type: `string`):

Only keep opportunities posted on or after this date (YYYY-MM-DD). Leave empty to include all returned dates.

## `postedTo` (type: `string`):

Only keep opportunities posted on or before this date (YYYY-MM-DD). Leave empty to include all returned dates.

## `noticeTypes` (type: `array`):

Optional SAM.gov notice type codes or labels to keep. Examples: o (Solicitation), k (Combined Synopsis/Solicitation), p (Presolicitation), r (Sources Sought).

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

Optional agency, department, or office name filter, such as Department of Defense, Veterans Affairs, or GSA.

## `naics` (type: `array`):

Optional NAICS codes to keep, for example 541512 or 236220.

## `psc` (type: `array`):

Optional Product Service Codes to keep, for example R499 or D399.

## `activeOnly` (type: `boolean`):

Skip inactive or closed opportunities when enabled.

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

Maximum number of matching opportunity records to save.

## `sort` (type: `string`):

Sort field used when requesting SAM.gov search result pages.

## `minEstimatedValue` (type: `integer`):

Optional minimum estimated value in USD. Many SAM.gov records do not expose an estimated value and will be skipped when this filter is set.

## `includeDescription` (type: `boolean`):

Save full cleaned description text when available. Keep disabled for smaller datasets.

## Actor input object example

```json
{
  "keywords": [
    "construction"
  ],
  "noticeTypes": [],
  "naics": [],
  "psc": [],
  "activeOnly": true,
  "maxItems": 20,
  "sort": "modifiedDate",
  "includeDescription": false
}
```

# Actor output Schema

## `overview` (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": [
        "construction"
    ],
    "noticeTypes": [],
    "naics": [],
    "psc": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/sam-gov-contract-opportunities-monitor").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": ["construction"],
    "noticeTypes": [],
    "naics": [],
    "psc": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/sam-gov-contract-opportunities-monitor").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": [
    "construction"
  ],
  "noticeTypes": [],
  "naics": [],
  "psc": []
}' |
apify call fetch_cat/sam-gov-contract-opportunities-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/sam-gov-contract-opportunities-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SAM.gov Contract Opportunities Monitor",
        "description": "Monitor US federal contract opportunities from SAM.gov with filters, normalized fields, direct notice links, and relevance scoring.",
        "version": "0.1",
        "x-build-id": "pZpF8VETawkAsq5lH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~sam-gov-contract-opportunities-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-sam-gov-contract-opportunities-monitor",
                "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/fetch_cat~sam-gov-contract-opportunities-monitor/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-sam-gov-contract-opportunities-monitor",
                "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/fetch_cat~sam-gov-contract-opportunities-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-sam-gov-contract-opportunities-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Opportunity search terms. Use product, service, agency mission, or capability keywords such as cybersecurity, construction, janitorial, cloud, or medical supplies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedFrom": {
                        "title": "Posted from",
                        "type": "string",
                        "description": "Only keep opportunities posted on or after this date (YYYY-MM-DD). Leave empty to include all returned dates."
                    },
                    "postedTo": {
                        "title": "Posted to",
                        "type": "string",
                        "description": "Only keep opportunities posted on or before this date (YYYY-MM-DD). Leave empty to include all returned dates."
                    },
                    "noticeTypes": {
                        "title": "Notice types",
                        "type": "array",
                        "description": "Optional SAM.gov notice type codes or labels to keep. Examples: o (Solicitation), k (Combined Synopsis/Solicitation), p (Presolicitation), r (Sources Sought).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "agency": {
                        "title": "Agency or office contains",
                        "type": "string",
                        "description": "Optional agency, department, or office name filter, such as Department of Defense, Veterans Affairs, or GSA."
                    },
                    "naics": {
                        "title": "NAICS codes",
                        "type": "array",
                        "description": "Optional NAICS codes to keep, for example 541512 or 236220.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "psc": {
                        "title": "PSC codes",
                        "type": "array",
                        "description": "Optional Product Service Codes to keep, for example R499 or D399.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeOnly": {
                        "title": "Active opportunities only",
                        "type": "boolean",
                        "description": "Skip inactive or closed opportunities when enabled.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum opportunities",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching opportunity records to save.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "modifiedDate",
                            "postedDate",
                            "responseDeadline",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort field used when requesting SAM.gov search result pages.",
                        "default": "modifiedDate"
                    },
                    "minEstimatedValue": {
                        "title": "Minimum estimated value",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum estimated value in USD. Many SAM.gov records do not expose an estimated value and will be skipped when this filter is set."
                    },
                    "includeDescription": {
                        "title": "Include full description",
                        "type": "boolean",
                        "description": "Save full cleaned description text when available. Keep disabled for smaller datasets.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
