# EU Tenders Scraper - TED Public Procurement Notices (`guyweitzman/eu-tenders-scraper`) Actor

Search EU public procurement notices (TED) by country, CPV, keyword, deadline and value. Returns flat, English-normalized rows instead of raw 24-language eForms.

- **URL**: https://apify.com/guyweitzman/eu-tenders-scraper.md
- **Developed by:** [Guy Weitzman](https://apify.com/guyweitzman) (community)
- **Categories:** News, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 tender notice scrapeds

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## EU Tenders Scraper - TED Public Procurement Notices

**Get EU public tenders as clean, flat rows you can filter in a spreadsheet - not raw 24-language XML.** Search every notice published in the Supplement to the Official Journal of the EU by country, sector, keyword, deadline and contract value.

> *Unofficial tool. Not affiliated with, endorsed by, or connected to the European Union or the Publications Office of the EU. It reads TED's public API, whose notices the EU explicitly permits reusing for commercial and non-commercial purposes.*

### What does EU Tenders Scraper do?

[TED (Tenders Electronic Daily)](https://ted.europa.eu) publishes every above-threshold public procurement notice in the EU and EEA - hundreds of thousands per year, worth hundreds of billions of euros. The raw data is public, but it arrives as multilingual eForms where a single field like the buyer's name is an object containing up to 24 translations, dates carry non-standard offsets, and the same CPV code repeats once per lot.

This Actor turns each notice into **one flat row with plain-English columns**: buyer, country name, notice type, value, currency, deadline, days remaining, sector, and the winner where a contract has been awarded. Download as JSON, CSV, Excel or HTML, pull it via API, or schedule it to run daily.

### How this compares to other TED Actors

Several Actors can fetch TED data. This one is built around three things they don't do:

1. **It normalizes instead of forwarding.** Others hand back TED's raw shape - a `buyer-name` object with 24 translations, repeated CPV codes, `can-standard` codes and `+02:00` dates. Here every row is already flat, English-labelled and spreadsheet-ready.
2. **It prices per notice, low.** Comparable Actors charge $0.005 to $0.10 per tender. This one charges a fraction of that, so pulling a full country-sector dataset costs cents rather than tens of dollars.
3. **It tells you why a run returned less than you asked.** Bad country code? You get "use DEU, not DE" with the exact failing value - not a stack trace or a silently empty dataset.

### Why use this Actor?

- **Normalized, not raw** - `"Netherlands"` instead of `["NLD"]`, `"Contract award notice"` instead of `"can-standard"`, `"IT services"` instead of `"72000000"`, ISO 8601 dates instead of `2026-07-01+02:00`.
- **Bid-ready filtering** - combine country, CPV sector, title keywords, publication window, minimum value, and "deadline on or after today" to get only the tenders you can still win.
- **Deadline urgency built in** - every row carries `daysUntilDeadline` and `isOpen`, so sorting by "closing soonest" needs no post-processing.
- **Award intelligence** - filter to `can-standard` notices to see who won, for how much, and from which buyer. Useful for competitor and pricing research.
- **One row per notice** - superseded revisions are filtered out by default, and results are deduplicated within a run, so you're never charged twice for the same publication number.
- **Honest limits** - when TED stops returning results, the run log says so instead of silently returning less than you asked for.
- **No API key, no account** - the Actor talks to TED's public API directly.

Typical buyers: B2B sales and bid teams tracking EU public-sector demand, tender consultancies, market researchers sizing public spend, and GovTech products that need a procurement feed.

### How to use it

1. Pick your filters - e.g. countries `DEU`, `FRA`; CPV `72000000` (IT services); deadline on or after today.
2. Set **Max results** as your spending cap.
3. Click **Start**, then export the dataset or fetch it from the API.
4. To monitor continuously, schedule the Actor daily with a `publishedFrom` of yesterday.

### Input

```json
{
    "countries": ["DEU", "NLD"],
    "cpvCodes": ["72000000", "48000000"],
    "keywords": ["cloud"],
    "noticeTypes": ["cn-standard"],
    "publishedFrom": "2026-06-01",
    "deadlineFrom": "2026-07-21",
    "minValue": 100000,
    "language": "eng",
    "maxItems": 1000
}
````

Every field is optional. With no filters at all, the Actor returns everything published in the last 30 days. Power users can pass a raw `customQuery` in [TED expert-search syntax](https://ted.europa.eu/en/simap/expert-search), which overrides the structured filters.

**Useful CPV prefixes:** `72000000` IT services · `48000000` software · `45000000` construction · `85000000` health & social · `79000000` business services · `71000000` engineering · `34000000` transport equipment.

**Useful notice types:** `cn-standard` open tenders · `can-standard` awarded contracts · `pin-only` early-warning notices.

### Output

```json
{
    "id": "502026-2026",
    "publicationNumber": "502026-2026",
    "title": "Netherlands – Computer support and consultancy services – Digitaal Dossier JGZ",
    "buyerName": "Stichting CJG Rijnmond",
    "buyerCountry": "Netherlands",
    "buyerCountryCode": "NLD",
    "noticeType": "can-standard",
    "noticeTypeLabel": "Contract award notice",
    "procedureType": "open",
    "contractNature": "services",
    "publicationDate": "2026-07-21T00:00:00.000Z",
    "deadline": null,
    "daysUntilDeadline": null,
    "isOpen": null,
    "totalValue": 8670000,
    "currency": "EUR",
    "cpvCodes": ["72600000"],
    "cpvMainCategory": "IT services",
    "placeOfPerformance": ["NL366", "NLD"],
    "winnerName": "Gino",
    "description": "CJG wil vanaf 1 januari 2027 ...",
    "noticeUrl": "https://ted.europa.eu/en/notice/-/detail/502026-2026",
    "xmlUrl": "https://ted.europa.eu/en/notice/502026-2026/xml",
    "pdfUrl": "https://ted.europa.eu/en/notice/502026-2026/pdf"
}
```

#### Data fields

| Field | Description |
|---|---|
| `publicationNumber` | TED identifier, e.g. `502026-2026` - stable and unique |
| `title`, `description` | Notice text in your chosen language, English fallback |
| `buyerName`, `buyerCountry`, `buyerCountryCode` | Contracting authority and its country |
| `noticeType`, `noticeTypeLabel` | Raw TED code plus a plain-English label |
| `procedureType`, `contractNature` | e.g. `open`, `services` |
| `publicationDate`, `deadline` | ISO 8601 timestamps |
| `daysUntilDeadline`, `isOpen` | Computed urgency for open tenders |
| `totalValue`, `currency` | Contract value where published |
| `cpvCodes`, `cpvMainCategory` | Sector codes plus a readable category |
| `placeOfPerformance` | NUTS/country codes, deduplicated |
| `winnerName` | Awarded supplier, on award notices |
| `noticeUrl`, `xmlUrl`, `pdfUrl` | Links to the official notice |
| `titleAllLanguages`, `buyerNameAllLanguages` | Every translation, when enabled |

### How much does it cost?

Pay per result: a small Actor-start fee plus a per-notice charge, on top of standard Apify platform usage. Rough guide at current rates:

- 1,000 notices: **≈ $0.60**
- 10,000 notices: **≈ $6.00**

**Max results** is a hard cap - the run stops charging the moment it's reached. Apify's free plan credit covers thousands of notices.

### Tips

- **Only tenders you can still bid on**: set `deadlineFrom` to today and `noticeTypes` to `cn-standard`.
- **Competitor research**: set `noticeTypes` to `can-standard` and read `winnerName` and `totalValue`.
- **Daily monitoring**: schedule the Actor with `publishedFrom` set to yesterday; each run then costs only what the new notices cost.
- **Value filters exclude notices without a published value** - many notices legitimately have none, so use `minValue` only when you specifically want valued contracts.
- Country codes are **3-letter** (`DEU`, not `DE`).

### FAQ

**Is this legal?** Yes. TED's own legal notice states the procurement notices "can be freely reused, for commercial or non-commercial purposes" under Commission Decision 2011/833/EU. This Actor uses TED's public API and does not bypass any access control.

**Is this an official EU product?** No. This is an unofficial Actor and is not affiliated with, endorsed by, or connected to the European Union or the Publications Office of the EU.

**Which countries are covered?** All EU member states plus EEA and other countries that publish to TED (Norway, Switzerland, Iceland, and candidate countries).

**Why do some notices have no deadline or value?** TED notice types differ - award notices have no future deadline, and many notices don't publish a value. Fields are `null` rather than guessed.

**Found a bug or need another field?** Open an issue in the Issues tab. TED exposes over 1,800 fields; the Actor surfaces the commercially useful subset and more can be added on request.

# Actor input Schema

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

3-letter country codes of the contracting authority, e.g. <code>DEU</code>, <code>FRA</code>, <code>NLD</code>. Leave empty for all EU/EEA countries.

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

EU Common Procurement Vocabulary codes. Use a division prefix to catch a whole sector - <code>72000000</code> = IT services, <code>48000000</code> = software, <code>45000000</code> = construction, <code>85000000</code> = health. <a href='https://simap.ted.europa.eu/cpv' target='_blank'>Full CPV list</a>.

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

Words that must appear in the notice title, e.g. <code>cloud</code>, <code>kubernetes</code>.

## `keywordMatch` (type: `string`):

Match notices containing ANY keyword, or only those containing ALL of them.

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

Filter by notice type. Most useful: <code>cn-standard</code> (open tenders you can still bid on), <code>can-standard</code> (awarded contracts - who won and for how much), <code>pin-only</code> (early-warning prior information). Leave empty for all types.

## `publishedFrom` (type: `string`):

Only notices published on or after this date. Format <code>YYYY-MM-DD</code>.

## `publishedTo` (type: `string`):

Only notices published on or before this date. Format <code>YYYY-MM-DD</code>.

## `deadlineFrom` (type: `string`):

Only notices whose submission deadline falls on or after this date - set it to today to get tenders you can still bid on. Format <code>YYYY-MM-DD</code>.

## `minValue` (type: `integer`):

Only notices with a total value above this amount. Note: many notices publish no value at all and will be excluded when this is set.

## `customQuery` (type: `string`):

Advanced: a raw TED expert-search query, e.g. <code>buyer-country IN (DEU) AND total-value > 1000000</code>. When set, it REPLACES all the filters above. <a href='https://ted.europa.eu/en/simap/expert-search' target='_blank'>Query syntax</a>.

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

TED publishes titles and buyer names in up to 24 languages. Pick the one to use for the flat text columns; English is used as a fallback when a notice has no text in your language.

## `includeAllLanguages` (type: `boolean`):

Adds <code>titleAllLanguages</code> and <code>buyerNameAllLanguages</code> objects containing every translation TED published. Off by default because it makes rows much larger.

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

Which field to order by. TED only supports descending order, so this returns the most recent publications or the latest deadlines first.

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

TED republishes a notice each time it is corrected. Keep this on to get one row per notice instead of every historical revision.

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

Hard cap on notices returned and charged for. TED often matches hundreds of thousands of notices - this is your spending limit.

## Actor input object example

```json
{
  "countries": [
    "DEU"
  ],
  "cpvCodes": [
    "72000000"
  ],
  "keywords": [],
  "keywordMatch": "any",
  "noticeTypes": [],
  "language": "eng",
  "includeAllLanguages": false,
  "sortBy": "publication-date",
  "onlyLatestVersions": true,
  "maxItems": 1000
}
```

# Actor output Schema

## `tenders` (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 = {
    "countries": [
        "DEU"
    ],
    "cpvCodes": [
        "72000000"
    ],
    "keywords": [],
    "noticeTypes": [],
    "publishedFrom": "",
    "publishedTo": "",
    "deadlineFrom": "",
    "customQuery": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("guyweitzman/eu-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 = {
    "countries": ["DEU"],
    "cpvCodes": ["72000000"],
    "keywords": [],
    "noticeTypes": [],
    "publishedFrom": "",
    "publishedTo": "",
    "deadlineFrom": "",
    "customQuery": "",
}

# Run the Actor and wait for it to finish
run = client.actor("guyweitzman/eu-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 '{
  "countries": [
    "DEU"
  ],
  "cpvCodes": [
    "72000000"
  ],
  "keywords": [],
  "noticeTypes": [],
  "publishedFrom": "",
  "publishedTo": "",
  "deadlineFrom": "",
  "customQuery": ""
}' |
apify call guyweitzman/eu-tenders-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Tenders Scraper - TED Public Procurement Notices",
        "description": "Search EU public procurement notices (TED) by country, CPV, keyword, deadline and value. Returns flat, English-normalized rows instead of raw 24-language eForms.",
        "version": "0.1",
        "x-build-id": "fDbztYZHjhCerZoYG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/guyweitzman~eu-tenders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-guyweitzman-eu-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/guyweitzman~eu-tenders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-guyweitzman-eu-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/guyweitzman~eu-tenders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-guyweitzman-eu-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": {
                    "countries": {
                        "title": "Buyer countries",
                        "type": "array",
                        "description": "3-letter country codes of the contracting authority, e.g. <code>DEU</code>, <code>FRA</code>, <code>NLD</code>. Leave empty for all EU/EEA countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cpvCodes": {
                        "title": "CPV codes",
                        "type": "array",
                        "description": "EU Common Procurement Vocabulary codes. Use a division prefix to catch a whole sector - <code>72000000</code> = IT services, <code>48000000</code> = software, <code>45000000</code> = construction, <code>85000000</code> = health. <a href='https://simap.ted.europa.eu/cpv' target='_blank'>Full CPV list</a>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Title keywords",
                        "type": "array",
                        "description": "Words that must appear in the notice title, e.g. <code>cloud</code>, <code>kubernetes</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordMatch": {
                        "title": "Keyword match",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "Match notices containing ANY keyword, or only those containing ALL of them.",
                        "default": "any"
                    },
                    "noticeTypes": {
                        "title": "Notice types",
                        "type": "array",
                        "description": "Filter by notice type. Most useful: <code>cn-standard</code> (open tenders you can still bid on), <code>can-standard</code> (awarded contracts - who won and for how much), <code>pin-only</code> (early-warning prior information). Leave empty for all types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publishedFrom": {
                        "title": "Published from",
                        "type": "string",
                        "description": "Only notices published on or after this date. Format <code>YYYY-MM-DD</code>."
                    },
                    "publishedTo": {
                        "title": "Published to",
                        "type": "string",
                        "description": "Only notices published on or before this date. Format <code>YYYY-MM-DD</code>."
                    },
                    "deadlineFrom": {
                        "title": "Deadline on or after",
                        "type": "string",
                        "description": "Only notices whose submission deadline falls on or after this date - set it to today to get tenders you can still bid on. Format <code>YYYY-MM-DD</code>."
                    },
                    "minValue": {
                        "title": "Minimum contract value (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only notices with a total value above this amount. Note: many notices publish no value at all and will be excluded when this is set."
                    },
                    "customQuery": {
                        "title": "Custom expert query",
                        "type": "string",
                        "description": "Advanced: a raw TED expert-search query, e.g. <code>buyer-country IN (DEU) AND total-value &gt; 1000000</code>. When set, it REPLACES all the filters above. <a href='https://ted.europa.eu/en/simap/expert-search' target='_blank'>Query syntax</a>."
                    },
                    "language": {
                        "title": "Output language",
                        "enum": [
                            "eng",
                            "deu",
                            "fra",
                            "spa",
                            "ita",
                            "nld",
                            "pol",
                            "por",
                            "swe",
                            "dan",
                            "fin",
                            "ces",
                            "ell",
                            "hun",
                            "ron"
                        ],
                        "type": "string",
                        "description": "TED publishes titles and buyer names in up to 24 languages. Pick the one to use for the flat text columns; English is used as a fallback when a notice has no text in your language.",
                        "default": "eng"
                    },
                    "includeAllLanguages": {
                        "title": "Also include all language variants",
                        "type": "boolean",
                        "description": "Adds <code>titleAllLanguages</code> and <code>buyerNameAllLanguages</code> objects containing every translation TED published. Off by default because it makes rows much larger.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "publication-date",
                            "deadline-receipt-request"
                        ],
                        "type": "string",
                        "description": "Which field to order by. TED only supports descending order, so this returns the most recent publications or the latest deadlines first.",
                        "default": "publication-date"
                    },
                    "onlyLatestVersions": {
                        "title": "Only latest versions",
                        "type": "boolean",
                        "description": "TED republishes a notice each time it is corrected. Keep this on to get one row per notice instead of every historical revision.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on notices returned and charged for. TED often matches hundreds of thousands of notices - this is your spending limit.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
