# US K-12 Cyber & IT RFP Monitor (`barking_wisdom/us-k12-cyber-it-rfp-monitor`) Actor

Find school district cybersecurity, managed IT, software, device, E-Rate, and edtech RFP leads for public-sector sales teams.

- **URL**: https://apify.com/barking\_wisdom/us-k12-cyber-it-rfp-monitor.md
- **Developed by:** [Влад](https://apify.com/barking_wisdom) (community)
- **Categories:** Lead generation, Business, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 qualified procurement opportunities

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

## US K-12 Cyber & IT RFP Monitor

Find public school district and municipal cybersecurity, managed IT, network
modernization, software, device, E-Rate and edtech procurement opportunities as
clean sales-lead data.

This Actor is built for public-sector sales teams that do not want to manually
check scattered district bid pages, PDF-heavy procurement sections and portal
lists every week.

### What You Get

- One dataset row per matched procurement opportunity.
- Buyer name, buyer type, state, source, title, URL, status and deadline when
  available.
- Matched keywords and a relevance score so sales teams can filter the list.
- Public attachment links grouped under the nearest opportunity when possible.
- Cross-run dedupe for scheduled monitoring with `emitOnlyNew`.
- Pay-per-event pricing tied to emitted `qualified_opportunity` rows.

### Best For

- Cybersecurity vendors selling endpoint, SIEM, MDR, vulnerability management,
  incident response, IAM or network security to school districts.
- MSPs and managed IT providers looking for school and municipal RFPs.
- Edtech, SIS, assessment, progress monitoring and infrastructure vendors.
- Public-sector BDR, RevOps and founder-led sales teams that need fresh leads
  in CSV, API, Sheets, CRM or alerts.

### What It Finds

The Actor crawls public procurement pages and looks for RFP, RFQ, bid and
proposal records that match cyber, IT, network, software, device, E-Rate and
edtech keywords.

It is a vertical lead monitor, not a generic tender database. Use it to find and
triage likely opportunities, then review the source page and attachments before
selling or bidding.

### Live Demo Results

Apify Cloud demo run on 2026-06-24:

- Actor: `barking_wisdom/us-k12-cyber-it-rfp-monitor`
- Run: `rZaaQecfVZddWnYJH`
- Dataset: `P5gkvtTfMhK8zyvbN`
- Public sources checked: 2
- Candidate links found: 125
- Qualified rows emitted: 31
- Failed requests: 0
- Pricing model in run metadata: `PAY_PER_EVENT`
- Charged events recorded: `qualified_opportunity = 30`
- Platform usage cost measured for the run: about `$0.00276`

Example rows from that live dataset:

| Opportunity | Buyer | State | Score | Matched keywords |
| --- | --- | --- | ---: | --- |
| Bid 3271 Information Technology Services Apple Devices | Jackson Public Schools | MS | 14 | information technology services, technology services, devices, apple devices |
| RFQ 2026-01 Rapid 7 Cybersecurity Software as a Service (SaaS) - Proposal (PDF) | Jackson Public Schools | MS | 12 | cybersecurity, software |
| Bid 3270 Information Technology Services Equipment and Devices | Jackson Public Schools | MS | 11 | information technology services, technology services, devices |
| Bid 3281 Jackson Public Schools Information Technology Services Equipment and Device | Jackson Public Schools | MS | 9 | information technology services, technology services |
| RFP 2026-10-26 Progress Monitoring Tool for English Learners (EL) | Jackson Public Schools | MS | 7 | progress monitoring |

For tighter sales lists, start with `minScore` of 5 or higher and review the
source page. Some public procurement pages list unrelated documents near IT
keyword text, so low-score rows are best treated as discovery leads.

### How To Use It

1. Run the default `school-district-pages` preset to inspect the output shape.
2. Tune `keywords`, `states`, `minScore` and `maxPagesPerSource` for your sales
   motion.
3. Export the dataset to CSV, Excel, JSON, Google Sheets, an Apify integration
   or your CRM workflow.
4. Schedule the Actor daily or weekly with `emitOnlyNew: true` so only new
   opportunities are emitted.
5. Use the `score`, `matchedKeywords`, `deadlineAt`, `attachmentUrls` and source
   links to qualify leads before outreach.

### Recommended Sales Input

```json
{
  "sourcePreset": "school-district-pages",
  "keywords": [
    "cybersecurity",
    "managed IT",
    "network security",
    "E-Rate",
    "network modernization",
    "information technology services",
    "student information system",
    "software",
    "devices"
  ],
  "lookbackDays": 365,
  "maxPagesPerSource": 25,
  "minScore": 5,
  "includeAttachments": true,
  "emitOnlyNew": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

For a broader discovery run, lower `minScore` to 1. For a cleaner sales-ready
feed, keep it at 5 or above.

### API And Automation Examples

Use the Actor as a scheduled lead feed:

```json
{
  "sourcePreset": "school-district-pages",
  "keywords": ["cybersecurity", "managed IT", "E-Rate", "network modernization"],
  "states": ["TX", "CA", "FL"],
  "minScore": 5,
  "emitOnlyNew": true
}
```

Run it from another workflow with the Apify API:

```bash
curl "https://api.apify.com/v2/acts/barking_wisdom~us-k12-cyber-it-rfp-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "sourcePreset": "school-district-pages",
    "keywords": ["cybersecurity", "managed IT", "E-Rate"],
    "minScore": 5,
    "emitOnlyNew": true
  }'
```

After the run finishes, export the default dataset to CSV, JSON, Excel, Google
Sheets or a webhook integration from Apify Console.

### Input Options

- `sourcePreset`: built-in public source group or `custom`.
- `startUrls`: public procurement pages for custom runs. API users can add
  `sourceName`, `buyerName`, `buyerType`, `state` and `adapter` metadata to
  each URL object.
- `keywords`: terms used for matching and scoring.
- `states`: optional US state filters.
- `minScore`: minimum relevance score for emitted rows.
- `lookbackDays`: optional freshness window for pages with dates.
- `maxPagesPerSource`: cap for bounded runs and predictable cost.
- `includeAttachments`: include public PDF, Word and spreadsheet links when
  detected.
- `emitOnlyNew`: enable for scheduled monitoring to avoid repeated rows across
  runs.
- `proxyConfiguration`: disabled by default because the intended sources are
  public pages.

### Output Fields

Each dataset row can include:

- `opportunityId`
- `title`
- `buyerName`
- `buyerType`
- `state`
- `sourceName`
- `sourceUrl`
- `opportunityUrl`
- `status`
- `publishedAt`
- `deadlineAt`
- `category`
- `matchedKeywords`
- `score`
- `summary`
- `attachmentUrls`
- `firstSeenAt`
- `lastSeenAt`

### Example Output

```json
{
  "title": "RFQ 2026-01 Rapid 7 Cybersecurity Software as a Service (SaaS) - Proposal (PDF)",
  "buyerName": "Jackson Public Schools",
  "buyerType": "school_district",
  "state": "MS",
  "status": "open",
  "matchedKeywords": ["cybersecurity", "software"],
  "score": 12,
  "opportunityUrl": "https://www.jackson.k12.ms.us/fs/resource-manager/view/1fefbb8a-5ab0-43cd-b583-eebb7057eeb2"
}
```

### Pricing

The Store model is pay-per-event for `qualified_opportunity` at `$0.05` per
qualified opportunity. The Actor calls the charge event automatically in Apify
Cloud when a qualified row is emitted. Local development runs do not charge
events.

### Compliance And Limits

This Actor is intended for public procurement pages only. It does not log in,
bypass access controls, solve CAPTCHA, collect private account data or guarantee
procurement completeness. Users are responsible for checking source terms,
reviewing source documents and using the results lawfully.

The dataset is organization and opportunity focused. It is not intended to
collect personal data.

### FAQ

#### Is this a complete K-12 tender database?

No. It is a focused monitoring Actor for public pages and configured sources.
It is best used as a fresh lead feed that your team can tune by state, keyword
and source.

#### Can I add my own districts or portals?

Yes. Use `sourcePreset: "custom"` and provide public procurement page URLs in
`startUrls`. For best output, include `buyerName`, `buyerType`, `state` and
`sourceName` metadata with each URL.

#### Should I use `emitOnlyNew`?

Use `emitOnlyNew: false` for sample or one-time discovery runs. Use
`emitOnlyNew: true` for daily or weekly monitoring so repeated opportunities do
not keep appearing in your feed.

#### Why do some low-score rows need manual review?

School district procurement pages often place unrelated bids, PDFs and category
text close together. The `score` and `matchedKeywords` fields make that visible.
Use higher `minScore` values for cleaner sales lists.

#### Does it use Apify Proxy?

Proxy is disabled by default. The Actor is designed for public procurement
pages. Enable proxy only if your configured sources require it and you are
comfortable with the extra cost.

### Good Next Workflows

- Schedule daily monitoring for a target state or region.
- Connect the dataset to Google Sheets, a webhook or a CRM import.
- Add custom district, city, county or procurement portal URLs with buyer
  metadata.
- Raise `minScore` for high-confidence lead lists or lower it for early market
  discovery.

# Actor input Schema

## `sourcePreset` (type: `string`):

Built-in public source group to crawl.

## `startUrls` (type: `array`):

Public procurement list pages to crawl when using the custom preset. API users may include optional sourceName, buyerName, buyerType, state, and adapter fields on each URL object.

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

Cyber, IT, network, software, and edtech terms used for matching.

## `states` (type: `array`):

Optional US state abbreviations. Empty means all states.

## `lookbackDays` (type: `integer`):

Only emit opportunities published or updated within this many days when dates are available.

## `maxPagesPerSource` (type: `integer`):

Hard cap to control cost and source impact.

## `minScore` (type: `integer`):

Minimum score required before an opportunity is emitted.

## `includeAttachments` (type: `boolean`):

Collect public attachment URLs when they are visible on the listing page.

## `emitOnlyNew` (type: `boolean`):

Enable for scheduled monitoring to avoid re-emitting opportunities already seen in previous runs. Leave disabled for sample/default Store runs so the dataset is not empty.

## `proxyConfiguration` (type: `object`):

Proxy settings. Public MVP defaults to no Apify proxy.

## Actor input object example

```json
{
  "sourcePreset": "school-district-pages",
  "startUrls": [],
  "keywords": [
    "cybersecurity",
    "cyber security",
    "managed it",
    "network security",
    "network modernization",
    "firewall",
    "endpoint detection",
    "erate",
    "information technology services",
    "student information system",
    "identity management",
    "single sign-on",
    "software as a service",
    "saas",
    "technology services"
  ],
  "states": [],
  "lookbackDays": 45,
  "maxPagesPerSource": 25,
  "minScore": 4,
  "includeAttachments": true,
  "emitOnlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": 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("barking_wisdom/us-k12-cyber-it-rfp-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("barking_wisdom/us-k12-cyber-it-rfp-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 '{}' |
apify call barking_wisdom/us-k12-cyber-it-rfp-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=barking_wisdom/us-k12-cyber-it-rfp-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US K-12 Cyber & IT RFP Monitor",
        "description": "Find school district cybersecurity, managed IT, software, device, E-Rate, and edtech RFP leads for public-sector sales teams.",
        "version": "0.1",
        "x-build-id": "uff8AnyKILRdG6feg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/barking_wisdom~us-k12-cyber-it-rfp-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-barking_wisdom-us-k12-cyber-it-rfp-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/barking_wisdom~us-k12-cyber-it-rfp-monitor/runs": {
            "post": {
                "operationId": "runs-sync-barking_wisdom-us-k12-cyber-it-rfp-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/barking_wisdom~us-k12-cyber-it-rfp-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-barking_wisdom-us-k12-cyber-it-rfp-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": [
                    "sourcePreset"
                ],
                "properties": {
                    "sourcePreset": {
                        "title": "Source preset",
                        "enum": [
                            "school-district-pages",
                            "opengov-school-districts",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Built-in public source group to crawl.",
                        "default": "school-district-pages"
                    },
                    "startUrls": {
                        "title": "Custom public procurement URLs",
                        "type": "array",
                        "description": "Public procurement list pages to crawl when using the custom preset. API users may include optional sourceName, buyerName, buyerType, state, and adapter fields on each URL object.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Cyber, IT, network, software, and edtech terms used for matching.",
                        "default": [
                            "cybersecurity",
                            "cyber security",
                            "managed it",
                            "network security",
                            "network modernization",
                            "firewall",
                            "endpoint detection",
                            "erate",
                            "information technology services",
                            "student information system",
                            "identity management",
                            "single sign-on",
                            "software as a service",
                            "saas",
                            "technology services"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "State filters",
                        "type": "array",
                        "description": "Optional US state abbreviations. Empty means all states.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lookbackDays": {
                        "title": "Lookback days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only emit opportunities published or updated within this many days when dates are available.",
                        "default": 45
                    },
                    "maxPagesPerSource": {
                        "title": "Max pages per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap to control cost and source impact.",
                        "default": 25
                    },
                    "minScore": {
                        "title": "Minimum relevance score",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum score required before an opportunity is emitted.",
                        "default": 4
                    },
                    "includeAttachments": {
                        "title": "Include attachment links",
                        "type": "boolean",
                        "description": "Collect public attachment URLs when they are visible on the listing page.",
                        "default": true
                    },
                    "emitOnlyNew": {
                        "title": "Emit only new opportunities",
                        "type": "boolean",
                        "description": "Enable for scheduled monitoring to avoid re-emitting opportunities already seen in previous runs. Leave disabled for sample/default Store runs so the dataset is not empty.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Public MVP defaults to no Apify proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
