# TED Procurement Radar (`actorpilot/ted-procurement-radar`) Actor

Monitor EU public procurement notices from TED with lead scoring (0–100), bid-status detection, NUTS region resolution, CPV categorization, and deadline tracking. Filter by country and CPV category.

- **URL**: https://apify.com/actorpilot/ted-procurement-radar.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## TED Procurement Radar - EU Tender Scraper (ted.europa.eu)

Monitor and extract EU public procurement notices from TED (Tenders Electronic Daily) through the official TED Search API. Search by keyword, CPV code, country, or notice number and get structured results for procurement intelligence, market research, and lead generation.

Try it free - about $0.001 per 10 notices.

---

### Who uses TED Procurement Radar

- **Business Development Managers** at IT services and consulting firms monitoring contracts in their sector
- **Procurement Officers** tracking competitor awards and market rates
- **Sales Teams** at construction, engineering, and technology companies identifying actionable leads
- **Market Researchers** analyzing public spending patterns by country and sector
- **Automation Engineers** building tender-alert pipelines with n8n, Zapier, or custom webhooks

---

### What does TED Procurement Radar do?

This Actor uses the official TED Search API and returns normalized procurement data that is ready for analysis, export, and integration.

In one run you can:

- Monitor new tenders by keyword
- Look up specific notice IDs
- Filter by country or CPV code
- Prioritize opportunities by value, deadline, and bid status
- Export structured procurement data into your CRM or BI workflow

---

### Why use TED Procurement Radar?

#### Official TED API, not HTML scraping

- More stable than browser scraping
- Faster and cheaper to run
- No JavaScript rendering needed
- Better resilience when TED changes its frontend

#### Useful for procurement intelligence

| Your need | How this Actor helps |
|---|---|
| Tender monitoring | Track fresh notices automatically |
| Market research | Filter by country, buyer type, and sector |
| Procurement intelligence | Analyze award winners, values, and deadlines |
| App development | Get normalized JSON instead of raw code-heavy API output |
| Lead generation | Filter to actionable notices with `canBid: true` |

#### Normalized output

The Actor converts raw procurement codes into human-readable labels, including CPV, NUTS, buyer legal type, and notice metadata.

---

### How to use TED Procurement Radar

1. Click **Try for free**
2. Enter a keyword or notice number in `searchPhrase`
3. Set `maxItems`
4. Enable `includeNoticeDetails` for richer output
5. Start the run
6. Download results as JSON, CSV, Excel, or XML

For ongoing monitoring, schedule daily or weekly runs on Apify.

---

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `searchPhrase` | string | Keyword or notice number | required |
| `maxItems` | integer | Maximum notices to return | 10 |
| `includeNoticeDetails` | boolean | Fetch full detail fields | true |
| `onlyLatestVersions` | boolean | Skip older amended versions | true |
| `maxRequestsPerCrawl` | integer | Limit fetched API pages | 3 |
| `searchCountry` | string | ISO 2-letter country code such as `DE` | none |
| `searchCpv` | string | CPV prefix such as `45` | none |
| `minEstimatedValueEur` | integer | Minimum contract value in EUR | 0 |
| `includeLeadScore` | boolean | Calculate a lead score | true |

Example input:

```json
{
  "searchPhrase": "solar energy",
  "maxItems": 50,
  "includeNoticeDetails": true,
  "onlyLatestVersions": true,
  "maxRequestsPerCrawl": 10,
  "searchCountry": "DE",
  "searchCpv": "09",
  "minEstimatedValueEur": 100000,
  "includeLeadScore": true
}
````

***

### Key CPV Code Reference

CPV (Common Procurement Vocabulary) codes classify contracts by type. Use the `searchCpv` input to filter by sector.

| CPV Prefix | Sector |
|---|---|
| `09` | Energy (electricity, gas, oil, nuclear) |
| `30` | Office and computing machinery |
| `33` | Medical equipment and pharmaceuticals |
| `45` | Construction works |
| `48` | Software packages and information systems |
| `50` | Repair and maintenance services |
| `71` | Architectural and engineering services |
| `72` | IT services (consulting, programming, support) |
| `79` | Business services (legal, marketing, recruitment) |
| `90` | Environmental services |

Tip: Use a 2-digit prefix (e.g. `72`) to catch all IT sub-categories, or a full 8-digit code for precision.

***

### Output

Each item represents one TED procurement notice.

Example output item:

```json
{
  "noticeId": "391694-2026",
  "url": "https://ted.europa.eu/en/notice/-/detail/391694-2026",
  "noticeTitle": "Electricity - Solar photovoltaic installation for community energy sharing",
  "noticeType": "Contract or concession notice - standard regime",
  "noticeStatus": "open",
  "canBid": true,
  "country": "Spain",
  "publicationDate": "2026-06-08",
  "deadlineDate": "2026-07-16",
  "deadlineDaysRemaining": 37,
  "urgencyFlag": false,
  "buyerName": "Pleno del Ayuntamiento de Talayuela",
  "buyerLegalType": "Local authority",
  "estimatedValueNum": 2601897.21,
  "estimatedValueCurrency": "EUR",
  "cpvMain": "09310000",
  "cpvMainLabel": "Electricity",
  "contractSizeCategory": "large (>1M EUR)",
  "leadScore": 80,
  "leadScoreReason": "Strong lead: EUR 2,601,897.21 contract value, 37 days to bid."
}
```

Key output fields:

- `noticeId`, `url`, `noticeTitle`, `noticeType`
- `noticeStatus`, `canBid`
- `buyerName`, `buyerLegalType`, `buyerCountry`
- `publicationDate`, `deadlineDate`, `deadlineDaysRemaining`
- `estimatedValueNum`, `estimatedValueCurrency`
- `cpvMain`, `cpvMainLabel`
- `leadScore`, `leadScoreReason`, `leadScoreFactors`

***

### Use with AI agents via Apify MCP

This Actor can be used from Claude, Codex, Cursor, VS Code, Windsurf, Zed, and other MCP-compatible AI tools through Apify's Actors MCP server.

Important: this Actor is not a standalone remote MCP server. You connect Apify's Actors MCP server once, then ask your assistant to use the TED actor.

#### MCP setup

Add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}
```

#### Copy-paste prompt for AI tools

If your assistant can configure MCP for you, paste this:

```text
Please set up Apify's Actors MCP server in my MCP configuration.

Use this package:
- command: npx
- args: -y @apify/actors-mcp-server

Set my APIFY_TOKEN in the MCP environment.

After setup, use the Apify actor "ted-procurement-radar" and help me search TED tenders from chat.
```

#### Example prompts after setup

- Use the `ted-procurement-radar` actor to find open German tenders for `cybersecurity` with at least EUR 100,000 estimated value.
- Search TED for `solar energy` notices in Spain and summarize the best opportunities.
- Look up notice `391742-2026` and explain whether it is still open for bidding.
- Run the actor for CPV code `45` and return the most urgent opportunities with deadlines in the next 14 days.

#### Client notes

- Claude, Codex, Cursor, VS Code, Windsurf, and Zed can usually use the stdio MCP config above directly.
- n8n, LangChain, OpenAI Agents SDK, Gemini, and custom apps can use the same Apify actor capability, but the exact MCP plumbing depends on the client environment.

***

### How much does it cost to scrape TED notices?

| Run size | Estimated cost |
|---|---|
| 10 notices | ~$0.001 |
| 100 notices | ~$0.01 |
| 1,000 notices | ~$0.10 |
| 10,000 notices | ~$1.00 |

New Apify accounts receive $5 in free monthly credits.

***

### Tips

- Use specific technical keywords instead of broad generic terms.
- Use local-language keywords for country-specific notice discovery.
- Schedule daily runs with `onlyLatestVersions: true` for monitoring workflows.
- Filter downstream to `canBid: true` if you only want active opportunities.
- Use direct notice IDs in `searchPhrase` for exact lookup.

#### Understanding the lead score

The lead score helps prioritize open notices. Higher scores usually indicate a combination of disclosed value, active deadline, useful bidding window, and strong commercial relevance.

***

### Automate Tender Monitoring

For ongoing monitoring, combine Apify scheduling with a notification channel:

**Apify Schedule + Webhook to Slack**

1. Open the Actor on Apify and click **Schedule**
2. Set a daily or weekly trigger
3. Under **Webhooks**, add a Slack incoming webhook URL
4. The Actor posts new tenders directly to your Slack channel

**Apify + n8n Pipeline**

1. Use the Apify n8n node to trigger the Actor on schedule
2. Filter results in n8n where `canBid: true` and `deadlineDaysRemaining < 30`
3. Create HubSpot deals or send email alerts for matching notices

**Direct API Integration**
Run the Actor via the Apify API and pull results into your CRM or BI tool:

```json
POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs
Authorization: Bearer YOUR_TOKEN
```

***

### FAQ

**Is this an official EU tool?**
No. This is an independent Actor built on the public TED Search API.

**Is it legal to use?**
TED publishes procurement notices as public information. You remain responsible for compliant use under applicable rules and Apify terms.

**Why not use the TED API directly?**
You can, but this Actor already handles pagination, normalization, label mapping, and export.

**Does it work for all EU countries?**
Yes, TED covers all EU member states and additional participating jurisdictions.

**What is a CPV code and how do I find the right one?**
CPV codes are standardised EU product/service classification codes. Use the table above as a starting point. For precise targeting, search the official CPV database at simap.ted.europa.eu.

**How do I get notified when new tenders appear?**
Schedule the Actor to run daily with `onlyLatestVersions: true`. Use Apify Webhooks or the n8n integration to push new results to Slack, email, or your CRM automatically.

**Can I monitor multiple countries at once?**
Run the Actor without a `searchCountry` filter to get results across all EU member states. Then filter downstream by the `country` field in the output.

**Do you support custom procurement workflows?**
Yes. Contact us through the Apify platform for custom monitoring or integration work.

# Actor input Schema

## `searchPhrase` (type: `string`):

Quick-search phrase used on TED, for example construction, railway, software, or a specific notice number.

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

Maximum number of notice rows to collect across search result pages.

## `includeNoticeDetails` (type: `boolean`):

If enabled, request the extended TED API field set for buyer, CPV, contract, and value information.

## `onlyLatestVersions` (type: `boolean`):

Use TED's latest-version filter to avoid older changed notice revisions where possible.

## `maxRequestsPerCrawl` (type: `integer`):

Safety limit for total TED API page requests during one run.

## `searchCountry` (type: `string`):

Only return notices from this EU country (ISO 2-letter code). Leave empty for all countries.

## `searchCpv` (type: `string`):

Only return notices matching this CPV code prefix (e.g. '45' for construction work, '72' for IT services). Leave empty for all sectors.

## `minEstimatedValueEur` (type: `integer`):

Only return notices with an estimated contract value above this threshold in EUR. Leave empty or set to 0 to disable.

## `includeLeadScore` (type: `boolean`):

Calculate a 0-100 lead relevance score for each notice based on estimated value, deadline urgency, contract type, and buyer authority. Recommended when includeNoticeDetails is enabled.

## Actor input object example

```json
{
  "searchPhrase": "construction",
  "maxItems": 10,
  "includeNoticeDetails": true,
  "onlyLatestVersions": true,
  "maxRequestsPerCrawl": 25,
  "minEstimatedValueEur": 0,
  "includeLeadScore": true
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorpilot/ted-procurement-radar").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/ted-procurement-radar").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 '{
  "maxItems": 10
}' |
apify call actorpilot/ted-procurement-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TED Procurement Radar",
        "description": "Monitor EU public procurement notices from TED with lead scoring (0–100), bid-status detection, NUTS region resolution, CPV categorization, and deadline tracking. Filter by country and CPV category.",
        "version": "1.0",
        "x-build-id": "geBpK0YZU73X9LU8R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorpilot~ted-procurement-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorpilot-ted-procurement-radar",
                "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/actorpilot~ted-procurement-radar/runs": {
            "post": {
                "operationId": "runs-sync-actorpilot-ted-procurement-radar",
                "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/actorpilot~ted-procurement-radar/run-sync": {
            "post": {
                "operationId": "run-sync-actorpilot-ted-procurement-radar",
                "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": [
                    "searchPhrase"
                ],
                "properties": {
                    "searchPhrase": {
                        "title": "Search phrase",
                        "type": "string",
                        "description": "Quick-search phrase used on TED, for example construction, railway, software, or a specific notice number.",
                        "default": "construction"
                    },
                    "maxItems": {
                        "title": "Max notices",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of notice rows to collect across search result pages.",
                        "default": 10
                    },
                    "includeNoticeDetails": {
                        "title": "Include notice details",
                        "type": "boolean",
                        "description": "If enabled, request the extended TED API field set for buyer, CPV, contract, and value information.",
                        "default": true
                    },
                    "onlyLatestVersions": {
                        "title": "Only latest versions",
                        "type": "boolean",
                        "description": "Use TED's latest-version filter to avoid older changed notice revisions where possible.",
                        "default": true
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max requests per crawl",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for total TED API page requests during one run.",
                        "default": 25
                    },
                    "searchCountry": {
                        "title": "Filter by country",
                        "enum": [
                            "AT",
                            "BE",
                            "BG",
                            "CY",
                            "CZ",
                            "DE",
                            "DK",
                            "EE",
                            "ES",
                            "FI",
                            "FR",
                            "GR",
                            "HR",
                            "HU",
                            "IE",
                            "IT",
                            "LT",
                            "LU",
                            "LV",
                            "MT",
                            "NL",
                            "PL",
                            "PT",
                            "RO",
                            "SE",
                            "SI",
                            "SK"
                        ],
                        "type": "string",
                        "description": "Only return notices from this EU country (ISO 2-letter code). Leave empty for all countries."
                    },
                    "searchCpv": {
                        "title": "Filter by CPV code prefix",
                        "type": "string",
                        "description": "Only return notices matching this CPV code prefix (e.g. '45' for construction work, '72' for IT services). Leave empty for all sectors."
                    },
                    "minEstimatedValueEur": {
                        "title": "Minimum estimated value (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return notices with an estimated contract value above this threshold in EUR. Leave empty or set to 0 to disable.",
                        "default": 0
                    },
                    "includeLeadScore": {
                        "title": "Include lead score",
                        "type": "boolean",
                        "description": "Calculate a 0-100 lead relevance score for each notice based on estimated value, deadline urgency, contract type, and buyer authority. Recommended when includeNoticeDetails is enabled.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
