# FPDS Federal Contracts Scraper (`automation-lab/fpds-federal-contracts-scraper`) Actor

Extract FPDS contract awards with vendors, agencies, NAICS, PSC, dates, values, competition, set-asides, and source URLs.

- **URL**: https://apify.com/automation-lab/fpds-federal-contracts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## FPDS Federal Contracts Scraper

Extract U.S. federal contract award records from the public FPDS Atom/XML feed. Use this actor to monitor awarded contracts, vendors, agencies, NAICS/PSC markets, obligated amounts, competition, set-asides, dates, and places of performance.

### What does FPDS Federal Contracts Scraper do?

FPDS Federal Contracts Scraper turns the public FPDS search feed into clean dataset rows. Instead of manually opening FPDS search pages and copying XML fields, you provide a query or filters and receive normalized contract award records ready for spreadsheets, dashboards, CRMs, and capture workflows.

### Who is it for?

- 🧭 GovCon business development teams tracking competitor awards.
- 🎯 Capture managers watching agencies, offices, NAICS codes, and recompete markets.
- 📊 Market researchers building federal spending intelligence datasets.
- 🧾 Compliance and operations teams reviewing contract actions and modifications.
- 🧪 Data analysts who need repeatable FPDS extraction without maintaining feed parsers.

### Why use this actor?

FPDS is rich but inconvenient. The Atom feed contains nested XML, namespaces, attributes, and one page of records at a time. This actor handles pagination, XML parsing, field normalization, and Apify dataset export so your workflow can focus on analysis.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Award IDs | PIID, award ID, modification, referenced IDV PIID |
| Vendors | Vendor name, UEI/DUNS when present, city, state, country |
| Agencies | Department, contracting agency, contracting office, funding agency |
| Values | Obligated amount, total obligated amount, base/all options value |
| Dates | Signed, effective, current completion, ultimate completion |
| Classification | NAICS, PSC, action type, pricing type |
| Competition | Extent competed, set-aside type |
| Geography | Place-of-performance state/country |
| Source | FPDS source URL and scrape timestamp |

### How much does it cost to scrape FPDS federal contract awards?

The actor uses pay-per-event pricing: a small start fee plus a per-record charge for each FPDS award row saved. Your first prefilled run is limited to 20 records, so it is suitable for a quick test before larger monitoring jobs.

| Run size | What it is good for | Estimated actor charge on the Free tier* |
| --- | --- | ---: |
| 20 records | Quick validation with the default prefill | about $0.0055 |
| 100 records | Small agency, NAICS, or vendor sample | about $0.0077 |
| 1,000 records | Larger market sizing export | about $0.0322 |
| 10,000 records | Broad monitoring or historical backfill segment | about $0.2767 |

\*Estimate uses the configured Free-tier event prices: $0.005 per run start plus $0.00002717 per saved FPDS award record. Paid Apify plans may use lower per-record tiers. Apify platform compute/proxy costs, if applicable to your account, are separate from actor event charges.

A Free-plan user can usually run multiple small FPDS tests because the default 20-record run is only about half a cent in actor charges. For budget control, start with `maxItems` between 20 and 100, inspect the output, and then increase the limit for scheduled monitoring.

### Input options

You can use a raw FPDS query, convenience filters, or both.

- `query` — raw FPDS ezsearch query such as `SIGNED_DATE:[2024/01/01,2024/12/31]`.
- `signedFrom` and `signedTo` — date range helper when the raw query does not already include `SIGNED_DATE`.
- `agency` — agency or department keyword.
- `vendor` — vendor keyword.
- `naicsCode` — NAICS keyword/code.
- `pscCode` — Product or Service Code keyword/code.
- `maxItems` — maximum records to save.
- `startOffset` — advanced pagination offset.

### Example input

```json
{
  "query": "SIGNED_DATE:[2024/01/01,2024/12/31]",
  "naicsCode": "541330",
  "maxItems": 100
}
````

### Example output

```json
{
  "awardId": "9700-0001-10-0",
  "piid": "0001",
  "vendorName": "STRATEGIC ANALYSIS, INC.",
  "contractingDepartmentName": "DEPT OF DEFENSE",
  "contractingAgencyName": "WASHINGTON HEADQUARTERS SERVICES (WHS)",
  "signedDate": "2024-03-08",
  "obligatedAmount": -1252.89,
  "totalObligatedAmount": 1550938.36,
  "naicsCode": "541330",
  "pscCode": "R499",
  "extentCompetedDescription": "FULL AND OPEN COMPETITION",
  "sourceUrl": "https://www.fpds.gov/ezsearch/search.do?..."
}
```

### How to scrape FPDS contract awards

1. Open the actor on Apify.
2. Enter a raw FPDS query or fill in the date and keyword helpers.
3. Set `maxItems` to the number of contract records you need.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, RSS, or via API.

### Query tips

- Use a date range to keep searches focused.
- Use NAICS and PSC keywords for market sizing.
- Use vendor keywords to monitor competitors.
- Use agency names to monitor buying offices.
- Start with 100 records before increasing to thousands.

### Common workflows

- 🏢 Competitor tracking: search a vendor name and collect recent awards.
- 🛰️ Agency monitoring: track a target agency's recent awards.
- 🧮 NAICS analysis: extract awards in one NAICS code for market sizing.
- 🧾 Modification review: include modifications to understand contract growth.
- 📍 Regional analysis: filter exported data by place of performance.

### Integrations

Send the dataset to:

- Google Sheets for capture lists.
- Airtable for opportunity and competitor databases.
- BI tools such as Power BI, Tableau, or Looker Studio.
- CRMs for account intelligence.
- Data warehouses through Apify API clients or webhooks.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fpds-federal-contracts-scraper').call({
  query: 'SIGNED_DATE:[2024/01/01,2024/12/31]',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/fpds-federal-contracts-scraper').call(run_input={
    'query': 'SIGNED_DATE:[2024/01/01,2024/12/31]',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fpds-federal-contracts-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"SIGNED_DATE:[2024/01/01,2024/12/31]","maxItems":100}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, Cursor, or VS Code through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/fpds-federal-contracts-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify-fpds "https://mcp.apify.com/?tools=automation-lab/fpds-federal-contracts-scraper"
```

Claude Desktop setup uses the same HTTP MCP endpoint in your Desktop configuration file:

```json
{
  "mcpServers": {
    "apify-fpds": {
      "transport": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/fpds-federal-contracts-scraper"
    }
  }
}
```

Cursor setup: open Cursor settings for MCP servers, add a new HTTP server named `apify-fpds`, and use this URL:

```text
https://mcp.apify.com/?tools=automation-lab/fpds-federal-contracts-scraper
```

VS Code setup: add the same server to your MCP extension or Copilot MCP configuration as an HTTP server named `apify-fpds` with the URL above. After saving the configuration, restart or reload the MCP server list so the FPDS federal contracts tool appears.

Example prompts:

- "Scrape 100 FPDS awards signed in 2024 and summarize top vendors."
- "Find recent FPDS contract awards for NAICS 541330."
- "Monitor federal contract awards for this vendor and export agency names."

### Output quality notes

FPDS XML fields vary by award type and source record. Some rows may not include UEI, DUNS, set-aside, or funding-office values. Missing source fields are returned as `null` rather than guessed.

### Performance notes

The public Atom feed returns about 10 records per page. Large jobs require multiple feed requests. Keep very broad searches bounded with `maxItems` and date filters.

### Troubleshooting

If you receive zero records, try a broader raw query such as `SIGNED_DATE:[2024/01/01,2024/12/31]`. If a convenience keyword is too narrow, remove it and filter the exported dataset instead.

### Legality

The actor uses the public FPDS feed for government procurement records. You are responsible for using exported data in compliance with applicable laws, policies, and platform terms.

### Is it legal to scrape FPDS?

FPDS is a public government procurement data source, and this actor reads public Atom/XML feed responses. Always apply your organization's data governance and attribution requirements.

### Related scrapers

- https://apify.com/automation-lab/samgov-government-contracts-scraper — pre-award SAM.gov opportunities.
- https://apify.com/automation-lab/usaspending-scraper — related U.S. federal spending data where applicable.

### FAQ

#### Does this require an FPDS login?

No. It uses the public FPDS Atom/XML feed.

#### Can I scrape more than 100 records?

Yes. Increase `maxItems`. For first tests, keep the default small.

#### Does it return contract documents?

No. It returns structured FPDS award metadata and source links.

#### Can I use raw FPDS query syntax?

Yes. Put the raw query in `query`. The helper fields are optional.

### Changelog

- 0.1 — Initial FPDS Atom feed scraper with normalized award records.

# Actor input Schema

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

Optional raw FPDS ezsearch query. Examples: VENDOR\_FULL\_NAME:"BOOZ ALLEN", CONTRACTING\_AGENCY\_NAME:"DEPT OF DEFENSE", NAICS\_CODE:541330. Optional filters below are appended with AND.

## `signedFrom` (type: `string`):

Inclusive signed date lower bound in YYYY-MM-DD format. Used only when the raw query does not already include SIGNED\_DATE.

## `signedTo` (type: `string`):

Inclusive signed date upper bound in YYYY-MM-DD format. Used only when the raw query does not already include SIGNED\_DATE.

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

Optional contracting agency or department keyword, such as DEPT OF DEFENSE, NASA, or GENERAL SERVICES ADMINISTRATION.

## `vendor` (type: `string`):

Optional recipient / vendor name keyword, such as BOOZ ALLEN, LOCKHEED, or STRATEGIC ANALYSIS.

## `naicsCode` (type: `string`):

Optional NAICS code filter, for example 541330 for Engineering Services.

## `pscCode` (type: `string`):

Optional Product or Service Code filter, for example R499 or 7030.

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

Maximum FPDS Atom feed records to extract. Keep the first run small, then increase for recurring market monitoring.

## `startOffset` (type: `integer`):

Optional zero-based FPDS pagination offset. Use for advanced continuation workflows.

## Actor input object example

```json
{
  "query": "SIGNED_DATE:[2024/01/01,2024/12/31]",
  "signedFrom": "2024-01-01",
  "signedTo": "2024-12-31",
  "maxItems": 20,
  "startOffset": 0
}
```

# 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 = {
    "query": "SIGNED_DATE:[2024/01/01,2024/12/31]",
    "signedFrom": "2024-01-01",
    "signedTo": "2024-12-31",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fpds-federal-contracts-scraper").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 = {
    "query": "SIGNED_DATE:[2024/01/01,2024/12/31]",
    "signedFrom": "2024-01-01",
    "signedTo": "2024-12-31",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fpds-federal-contracts-scraper").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 '{
  "query": "SIGNED_DATE:[2024/01/01,2024/12/31]",
  "signedFrom": "2024-01-01",
  "signedTo": "2024-12-31",
  "maxItems": 20
}' |
apify call automation-lab/fpds-federal-contracts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fpds-federal-contracts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FPDS Federal Contracts Scraper",
        "description": "Extract FPDS contract awards with vendors, agencies, NAICS, PSC, dates, values, competition, set-asides, and source URLs.",
        "version": "0.1",
        "x-build-id": "K8Mpjl9ujDDfVkcJm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fpds-federal-contracts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fpds-federal-contracts-scraper",
                "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/automation-lab~fpds-federal-contracts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fpds-federal-contracts-scraper",
                "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/automation-lab~fpds-federal-contracts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fpds-federal-contracts-scraper",
                "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": [
                    "maxItems"
                ],
                "properties": {
                    "query": {
                        "title": "FPDS query",
                        "type": "string",
                        "description": "Optional raw FPDS ezsearch query. Examples: VENDOR_FULL_NAME:\"BOOZ ALLEN\", CONTRACTING_AGENCY_NAME:\"DEPT OF DEFENSE\", NAICS_CODE:541330. Optional filters below are appended with AND."
                    },
                    "signedFrom": {
                        "title": "Signed from",
                        "type": "string",
                        "description": "Inclusive signed date lower bound in YYYY-MM-DD format. Used only when the raw query does not already include SIGNED_DATE."
                    },
                    "signedTo": {
                        "title": "Signed to",
                        "type": "string",
                        "description": "Inclusive signed date upper bound in YYYY-MM-DD format. Used only when the raw query does not already include SIGNED_DATE."
                    },
                    "agency": {
                        "title": "Agency keyword",
                        "type": "string",
                        "description": "Optional contracting agency or department keyword, such as DEPT OF DEFENSE, NASA, or GENERAL SERVICES ADMINISTRATION."
                    },
                    "vendor": {
                        "title": "Vendor keyword",
                        "type": "string",
                        "description": "Optional recipient / vendor name keyword, such as BOOZ ALLEN, LOCKHEED, or STRATEGIC ANALYSIS."
                    },
                    "naicsCode": {
                        "title": "NAICS code",
                        "type": "string",
                        "description": "Optional NAICS code filter, for example 541330 for Engineering Services."
                    },
                    "pscCode": {
                        "title": "PSC code",
                        "type": "string",
                        "description": "Optional Product or Service Code filter, for example R499 or 7030."
                    },
                    "maxItems": {
                        "title": "Maximum contract award records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum FPDS Atom feed records to extract. Keep the first run small, then increase for recurring market monitoring.",
                        "default": 20
                    },
                    "startOffset": {
                        "title": "Start offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional zero-based FPDS pagination offset. Use for advanced continuation workflows.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```