# TED Europa Tenders Scraper (`automation-lab/ted-europa-tenders-scraper`) Actor

Find EU public procurement tenders from TED by keyword, country, CPV code, buyer, deadline, and value. Export clean tender leads.

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

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TED Europa Tenders Scraper

Extract public procurement opportunities from TED (Tenders Electronic Daily), the official EU public procurement portal. Search by keyword, buyer, country, CPV code, publication date, and deadline, then export clean tender records to JSON, CSV, Excel, or your data pipeline.

### What does TED Europa Tenders Scraper do?

TED Europa Tenders Scraper queries the public TED notices API and saves structured tender notice data.

It helps you collect:

- 🔎 Tender publication numbers
- 🏛️ Buyer and public authority names
- 🧾 Tender titles and notice text matches
- 📅 Submission deadlines when available
- 💶 Estimated contract values when available
- 🏷️ CPV procurement category codes
- 🌍 Country/location indicators
- 🔗 Direct TED HTML, PDF, and XML links

### Who is it for?

This scraper is built for procurement and public-sector sales teams that need repeatable EU tender monitoring.

Typical users include:

- B2G sales teams tracking opportunities in target countries
- Bid managers watching deadline-driven tender pipelines
- Market-intelligence analysts measuring public-sector demand
- Consultants monitoring buyer activity and CPV categories
- Agencies building lead lists from public procurement notices
- Data teams feeding tender alerts into CRMs or warehouses

### Why use it?

TED is high-value but manual searching is slow. This Actor turns repeat searches into structured exports that can be scheduled, filtered, and integrated.

Benefits:

- ✅ API-first collection from a public EU source
- ✅ No browser automation required for the main extraction
- ✅ No login or private token required
- ✅ Works well for scheduled searches
- ✅ Exports to Apify datasets, API, webhooks, and integrations

### What data can you extract?

| Field | Description |
| --- | --- |
| `publicationNumber` | TED publication number, e.g. `399019-2026` |
| `noticeTitle` | Localized notice title when present |
| `buyerName` | Buyer or public authority name |
| `deadlineDate` | Tender/deadline date returned by TED |
| `estimatedValue` | Numeric estimated value when available |
| `estimatedValueCurrency` | Currency text when available |
| `cpvCodes` | CPV category codes |
| `countryCodes` | Country/location codes returned by TED |
| `tedUrl` | Direct TED HTML notice URL |
| `pdfUrl` | TED PDF URL when available |
| `xmlUrl` | TED XML URL when available |
| `sourceApiUrl` | Public TED API endpoint used by the Actor |

### How much does it cost to scrape TED Europa tenders?

This Actor uses pay-per-event pricing: a small run-start event plus a per-tender result event.

Configured pricing:

| Event | When charged | Price |
| --- | --- | ---: |
| Run start | Once per Actor run | $0.005 |
| Tender scraped — FREE tier | Per tender notice saved | $0.000115 |
| Tender scraped — BRONZE tier | Per tender notice saved | $0.000100 |
| Tender scraped — SILVER tier | Per tender notice saved | $0.000078 |
| Tender scraped — GOLD tier | Per tender notice saved | $0.000060 |
| Tender scraped — PLATINUM tier | Per tender notice saved | $0.000040 |
| Tender scraped — DIAMOND tier | Per tender notice saved | $0.000028 |

Example cost formula before Apify platform credits or plan-specific discounts:

| Saved tender notices | FREE tier estimate | BRONZE tier estimate |
| ---: | --- | --- |
| 25 | 0.005 start + 25 × 0.000115 = 0.007875 USD | 0.005 start + 25 × 0.000100 = 0.007500 USD |
| 100 | 0.005 start + 100 × 0.000115 = 0.016500 USD | 0.005 start + 100 × 0.000100 = 0.015000 USD |
| 1,000 | 0.005 start + 1,000 × 0.000115 = 0.120000 USD | 0.005 start + 1,000 × 0.000100 = 0.105000 USD |

For most users, the cost scales with the number of tender notices saved. Small test searches can be run cheaply by setting a low `maxItems` value. With Apify's free monthly platform credits, typical small checks of 25-100 tender notices should fit comfortably inside the free allowance unless you run many searches or combine them with other paid Actor usage.

### Quick start

1. Open the Actor on Apify.
2. Enter one or more keywords such as `software`, `construction`, or `medical equipment`.
3. Optionally add country codes such as `DEU`, `FRA`, or `ESP`.
4. Optionally add CPV codes such as `48000000`.
5. Set `maxItems` to the number of tenders you want.
6. Run the Actor.
7. Export results from the dataset.

### Input options

#### Keywords

Use `keywords` for simple full-text searches. Multiple keywords are joined with OR logic inside the generated TED query.

Example:

```json
{
  "keywords": ["software", "cloud services"],
  "maxItems": 25
}
````

#### Countries

Use TED country codes, for example:

- `DEU` Germany
- `FRA` France
- `ESP` Spain
- `ITA` Italy
- `NLD` Netherlands
- `POL` Poland

#### CPV codes

CPV codes target procurement categories. For example, `48000000` is commonly used for software package and information systems.

#### Buyer name

Use `buyerName` to find tenders where the public buyer/authority matches a text fragment.

#### Dates

Use:

- `publicationDateFrom` for notices published on or after a date
- `deadlineDateFrom` for notices with a deadline on or after a date

Dates must use `YYYY-MM-DD` format.

### Expert query mode

Advanced users can pass `expertQuery` to use TED expert search syntax directly. When `expertQuery` is set, it overrides the generated keyword/country/CPV/date filters.

Example:

```json
{
  "expertQuery": "FT ~ \"software\" AND CY = \"DEU\" SORT BY PD DESC",
  "maxItems": 50
}
```

### Example input

```json
{
  "keywords": ["software"],
  "countries": ["DEU"],
  "sortBy": "publication-date-desc",
  "language": "eng",
  "maxItems": 25,
  "pageSize": 50,
  "includeRawNotice": false
}
```

### Example output

```json
{
  "publicationNumber": "399019-2026",
  "noticeTitle": "Software services and related services",
  "buyerName": "Example public authority",
  "deadlineDate": "2026-07-15",
  "estimatedValue": 250000,
  "estimatedValueCurrency": "EUR",
  "cpvCodes": ["48000000"],
  "countryCodes": ["DEU"],
  "tedUrl": "https://ted.europa.eu/en/notice/399019-2026/html",
  "pdfUrl": "https://ted.europa.eu/en/notice/399019-2026/pdf",
  "xmlUrl": "https://ted.europa.eu/en/notice/399019-2026/xml",
  "sourceApiUrl": "https://api.ted.europa.eu/v3/notices/search"
}
```

### Tips for better results

- Start with broad keywords, then narrow with countries or CPV codes.
- Use `publicationDateFrom` for fresh market monitoring.
- Use `deadlineDateFrom` for bid pipeline searches.
- Keep `maxItems` low while testing a new query.
- Use `expertQuery` only when you know TED expert syntax.

### Integrations

You can connect tender data to:

- CRM lead queues for public-sector sales
- Slack or email alerts for bid teams
- Google Sheets for weekly tender reviews
- BI dashboards for market intelligence
- Data warehouses for procurement analytics
- MCP-enabled agent workflows for natural-language tender research

### Scheduling workflows

Schedule the Actor daily or weekly to watch new TED notices.

A common workflow:

1. Run one Actor task per target country or CPV group.
2. Use `publicationDateFrom` or a rolling expert query.
3. Send new dataset items to a webhook.
4. Deduplicate by `publicationNumber` in your system.
5. Route matching opportunities to the right sales owner.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ted-europa-tenders-scraper').call({
  keywords: ['software'],
  countries: ['DEU'],
  maxItems: 25,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/ted-europa-tenders-scraper').call(run_input={
    'keywords': ['software'],
    'countries': ['DEU'],
    'maxItems': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ted-europa-tenders-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["software"],"countries":["DEU"],"maxItems":25}'
```

### MCP usage

Use the Apify MCP server to run this Actor from AI tools.

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/ted-europa-tenders-scraper
```

Claude Code setup:

```bash
claude mcp add apify-ted-tenders https://mcp.apify.com/?tools=automation-lab/ted-europa-tenders-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-ted-tenders": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ted-europa-tenders-scraper"
    }
  }
}
```

Example prompts:

- “Find recent German software tenders on TED and summarize the buyers.”
- “Search TED for medical equipment tenders in France and list deadlines.”
- “Run the TED Europa Tenders Scraper for CPV 48000000 and export top results.”

### Data quality notes

TED notices vary by notice type, country, buyer, and publication year. Some notices do not include all fields.

For example:

- Estimated value may be missing.
- Deadline may be missing for some historical or award notices.
- CPV codes may be nested or unavailable in certain records.
- Localized titles can differ across languages.

### FAQ

#### Can I scrape TED tenders without an account?

Yes. The Actor uses the public TED notices API and does not require a TED login for the supported search/export workflow.

#### Does it download every tender attachment?

No. The Actor returns TED HTML, PDF, and XML links. Full attachment parsing is intentionally outside the MVP to keep runs fast and inexpensive.

### Troubleshooting

#### Why did I get no results?

Your filters may be too narrow. Try removing CPV or country filters, reducing date constraints, or using a broader keyword.

#### Why is a value or deadline empty?

TED does not provide every field for every notice. Empty fields usually mean the source notice did not include that value in the selected API fields.

#### Why did my expert query fail?

TED expert syntax is strict. Test a simpler query such as `FT ~ "software"` first, then add filters one by one.

### Legality and compliance

This Actor extracts publicly available procurement notice data from TED. You are responsible for using the data in compliance with applicable laws, platform terms, and your organization’s procurement policies.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/company-info-scraper
- https://apify.com/automation-lab/linkedin-company-scraper
- https://apify.com/automation-lab/yellow-pages-scraper

### Limits

The Actor is designed for structured TED notice search, not full attachment parsing. It returns direct TED document links so you can fetch PDFs/XML separately if needed.

### Support

If a query that works on the TED website fails in this Actor, include your input JSON and the TED query you expected so the issue can be reproduced quickly.

# Actor input Schema

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

Free-text phrases to search in TED full text, for example software, construction, or medical equipment.

## `expertQuery` (type: `string`):

Optional raw TED expert query. When set, it overrides the generated filters.

## `countries` (type: `array`):

TED country codes to filter by, e.g. DEU, FRA, ESP, ITA. Leave empty for all countries.

## `cpvCodes` (type: `array`):

CPV procurement category codes such as 48000000 for software package and information systems.

## `buyerName` (type: `string`):

Optional public authority or buyer name text filter.

## `publicationDateFrom` (type: `string`):

Only include notices published on or after this date (YYYY-MM-DD).

## `deadlineDateFrom` (type: `string`):

Only include notices with a deadline on or after this date (YYYY-MM-DD).

## `sortBy` (type: `string`):

Sort expression to apply to generated TED queries.

## `language` (type: `string`):

Three-letter TED language code used for localized titles, buyers, and links.

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

Maximum number of TED tender notices to save.

## `pageSize` (type: `integer`):

TED API page size. Smaller values are useful for quick tests.

## `includeRawNotice` (type: `boolean`):

Attach the raw TED API notice object to each dataset item for advanced debugging/enrichment.

## Actor input object example

```json
{
  "keywords": [
    "software"
  ],
  "countries": [
    "DEU"
  ],
  "sortBy": "publication-date-desc",
  "language": "eng",
  "maxItems": 20,
  "pageSize": 50,
  "includeRawNotice": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "software"
    ],
    "countries": [
        "DEU"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ted-europa-tenders-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 = {
    "keywords": ["software"],
    "countries": ["DEU"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ted-europa-tenders-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 '{
  "keywords": [
    "software"
  ],
  "countries": [
    "DEU"
  ]
}' |
apify call automation-lab/ted-europa-tenders-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TED Europa Tenders Scraper",
        "description": "Find EU public procurement tenders from TED by keyword, country, CPV code, buyer, deadline, and value. Export clean tender leads.",
        "version": "0.1",
        "x-build-id": "NqmE0uZT4bDM0oxdQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ted-europa-tenders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ted-europa-tenders-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~ted-europa-tenders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ted-europa-tenders-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~ted-europa-tenders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ted-europa-tenders-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Free-text phrases to search in TED full text, for example software, construction, or medical equipment.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "expertQuery": {
                        "title": "Raw TED expert query",
                        "type": "string",
                        "description": "Optional raw TED expert query. When set, it overrides the generated filters."
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "TED country codes to filter by, e.g. DEU, FRA, ESP, ITA. Leave empty for all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cpvCodes": {
                        "title": "CPV codes",
                        "type": "array",
                        "description": "CPV procurement category codes such as 48000000 for software package and information systems.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyerName": {
                        "title": "Buyer name contains",
                        "type": "string",
                        "description": "Optional public authority or buyer name text filter."
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include notices published on or after this date (YYYY-MM-DD)."
                    },
                    "deadlineDateFrom": {
                        "title": "Deadline date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include notices with a deadline on or after this date (YYYY-MM-DD)."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "publication-date-desc",
                            "publication-date-asc",
                            "deadline-date-asc"
                        ],
                        "type": "string",
                        "description": "Sort expression to apply to generated TED queries.",
                        "default": "publication-date-desc"
                    },
                    "language": {
                        "title": "Preferred language",
                        "type": "string",
                        "description": "Three-letter TED language code used for localized titles, buyers, and links.",
                        "default": "eng"
                    },
                    "maxItems": {
                        "title": "Maximum tenders",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of TED tender notices to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "TED API page size. Smaller values are useful for quick tests.",
                        "default": 50
                    },
                    "includeRawNotice": {
                        "title": "Include raw TED notice",
                        "type": "boolean",
                        "description": "Attach the raw TED API notice object to each dataset item for advanced debugging/enrichment.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```