# Trivago Hotel Scraper and Lead Finder (`esrok/trivago-hotel-scraper-lead-finder`) Actor

Extract public Trivago hotel listings, visible prices, ratings, review counts, provider counts, images, and hotel metadata for travel research, price comparison, market analysis, and B2B lead-generation workflows.

- **URL**: https://apify.com/esrok/trivago-hotel-scraper-lead-finder.md
- **Developed by:** [Esrok](https://apify.com/esrok) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Trivago Hotel Scraper and Lead Finder

Extract public Trivago hotel listing data for hotel research, price comparison, travel market analysis, competitor tracking, and B2B lead-generation workflows.

This Actor lets you enter a destination such as `Amsterdam`, `London`, `Paris`, or `Barcelona` and returns clean hotel listing records that can be exported to CSV, Excel, JSON, Google Sheets, Make, Zapier, n8n, or your own systems through the Apify API.

### What this Actor does

The Actor extracts publicly visible hotel listing data from Trivago destination pages, including:

- hotel name
- public Trivago hotel URL
- destination, city, and country
- star rating when visible
- guest rating and review count when visible
- visible listing-card price when available
- visible booking provider count when available
- image URL when visible
- public listing highlights
- ranking position
- source search URL
- scrape timestamp

The Actor does not log in, does not scrape private accounts, does not bypass paywalls, and does not collect guest or reviewer personal data.

### Why use it

Manual hotel research is slow. This Actor turns public Trivago listing pages into a structured dataset that can be filtered, enriched, exported, monitored, or loaded into a CRM.

Use it to:

- collect public hotel listings by destination
- compare visible listing-card prices
- research hotel competition in a city
- collect public ratings and review counts
- build destination-level hotel databases
- feed hotel data into outreach and lead-generation workflows
- monitor public listing changes over time with Apify schedules

### Who it is for

- travel agencies
- hotel marketers
- B2B lead-generation teams
- hotel outreach teams
- market researchers
- price comparison researchers
- tourism data analysts
- automation builders using Apify, Make, Zapier, n8n, or Google Sheets

### Input

| Field | Type | Description |
| --- | --- | --- |
| `destination` | string | City, region, country, landmark, or public Trivago destination URL. |
| `checkIn` | string | Optional `YYYY-MM-DD` check-in date. Returned in output for downstream workflows. |
| `checkOut` | string | Optional `YYYY-MM-DD` check-out date. Must be after check-in. |
| `adults` | integer | Number of adults to record with the run. |
| `rooms` | integer | Number of rooms to record with the run. |
| `currency` | string | Optional preferred currency. Trivago decides what currency is visible on the public page. |
| `maxResults` | integer | Maximum hotel listing records to return. |
| `includePrices` | boolean | Include public visible price fields when available. |
| `includeBookingProviders` | boolean | Include provider count and provider fields when available. |
| `includeImages` | boolean | Include public image URLs when available. |
| `includeRatings` | boolean | Include rating fields when available. |
| `includeAmenities` | boolean | Include public listing highlights when available. |
| `deduplicateResults` | boolean | Remove duplicate hotels using Trivago IDs and URLs. |
| `proxyConfiguration` | object | Apify proxy configuration. Residential proxies are recommended for cloud runs if datacenter traffic is blocked. |
| `maxRetries` | integer | Number of retries for public page requests. |
| `debugMode` | boolean | Save debug HTML and parsing summary to key-value store. |

### Example input

```json
{
  "destination": "Amsterdam",
  "checkIn": "2026-07-01",
  "checkOut": "2026-07-02",
  "adults": 2,
  "rooms": 1,
  "currency": "EUR",
  "maxResults": 100,
  "includePrices": true,
  "includeBookingProviders": true,
  "includeImages": true,
  "includeRatings": true,
  "includeAmenities": true,
  "deduplicateResults": true
}
````

### Output

Each dataset item represents one public Trivago hotel listing.

```json
{
  "hotelName": "Example Hotel Amsterdam",
  "hotelUrl": "https://www.trivago.com/en-US/oar/example-hotel-amsterdam?search=100-123456",
  "trivagoUrl": "https://www.trivago.com/en-US/oar/example-hotel-amsterdam?search=100-123456",
  "destination": "Amsterdam",
  "city": "Amsterdam",
  "country": "Netherlands",
  "starRating": 4,
  "guestRating": 8.6,
  "reviewCount": 1248,
  "price": 129,
  "currency": "EUR",
  "pricePerNight": 129,
  "checkIn": "2026-07-01",
  "checkOut": "2026-07-02",
  "bookingProvider": null,
  "providerUrl": null,
  "allVisibleProviders": [],
  "providerCount": 18,
  "imageUrl": "https://imgcy.trivago.com/...",
  "visibleHighlights": [
    "Excellent public transport access"
  ],
  "rankingPosition": 1,
  "sourceSearchUrl": "https://www.trivago.com/en-US/odr/hotels-amsterdam-netherlands?search=200-27561",
  "scrapedAt": "2026-05-30T00:00:00.000Z"
}
```

Fields that are not publicly visible on the listing page are returned as `null` or empty arrays.

### How to run

#### On Apify

1. Open the Actor.
2. Enter a destination.
3. Optionally enter check-in and check-out dates.
4. Choose the maximum number of results.
5. Run the Actor.
6. Export the dataset as CSV, Excel, JSON, or access it through the Apify API.

#### Locally

```bash
npm install
npm start
```

For local testing with Apify storage:

```bash
mkdir storage\key_value_stores\default
copy examples\local-smoke-input.json storage\key_value_stores\default\INPUT.json
npm start
```

### Export and integrations

Because the Actor stores records in the default Apify dataset, results can be used with:

- CSV, Excel, JSON, XML, RSS, and HTML exports
- Apify API dataset endpoints
- Google Sheets integrations
- Make scenarios
- Zapier workflows
- n8n workflows
- webhooks and scheduled runs
- CRM imports and enrichment pipelines

### Responsible use

Use this Actor only for lawful research, market analysis, and lead-generation workflows based on public Trivago listing data.

Do not use it to:

- scrape private user data
- collect guest or reviewer personal data
- bypass logins, paywalls, or access controls
- overload Trivago or booking providers
- misrepresent your relationship with Trivago
- use Trivago logos or protected brand assets in your own marketing

Always review your use case for compliance with applicable laws, platform terms, and data protection rules.

### Limitations

- Trivago public destination pages commonly expose a limited set of listing cards in the initial public HTML.
- Live provider names, exact availability, and exact stay-date pricing may not be visible on every public listing page.
- Check-in, check-out, adults, rooms, and preferred currency are recorded in output for downstream workflows; public SEO listing pages may still show forecasted or general listing-card prices.
- Provider URLs are only returned when publicly visible on the listing card.
- Hotel emails and phone numbers are not collected in version 1.
- If Trivago blocks a request from a datacenter IP, use Apify Residential proxy.

### Pricing

Recommended Apify Store monetization:

- Pricing model: Pay per event
- Primary event: `apify-default-dataset-item`
- Price: `$0.005` per hotel listing result
- Equivalent: `$5.00 per 1,000 hotel listing records`
- Keep the synthetic `apify-actor-start` event enabled at the Apify default.

This maps user cost directly to delivered hotel records and keeps pricing easy to understand.

### FAQ

#### Does this scrape private data?

No. It extracts public hotel listing data visible on Trivago destination pages.

#### Does it collect hotel emails?

No. Version 1 focuses on public hotel listings, visible prices, ratings, provider counts, image URLs, and metadata. Email discovery can be added later only from public hotel websites and only with a separate responsible-use review.

#### Why are some fields null?

Trivago does not expose every field for every listing. The Actor keeps the output schema stable and returns `null` or empty arrays when a field is not publicly visible.

#### Can I schedule price monitoring?

Yes. Use Apify schedules to run the Actor repeatedly and compare datasets over time. A future version can add changed-price-only output.

#### Can I use the output in Google Sheets?

Yes. Export the Apify dataset to CSV or connect Apify to Google Sheets, Make, Zapier, or n8n.

#### Is this affiliated with Trivago?

No. This Actor is an independent tool for extracting public listing data and does not use Trivago branding or logos.

# Actor input Schema

## `destination` (type: `string`):

City, region, country, landmark, or a public Trivago destination URL. Examples: Amsterdam, London, Paris, Barcelona.

## `checkIn` (type: `string`):

Optional check-in date in YYYY-MM-DD format. The Actor returns this value in each row for downstream workflows. Trivago public listing pages may still show forecasted public prices instead of exact stay-date prices.

## `checkOut` (type: `string`):

Optional check-out date in YYYY-MM-DD format. Must be after the check-in date when both are provided.

## `adults` (type: `integer`):

Number of adult guests to record with the run. Public Trivago SEO listing pages may not expose guest-specific live pricing.

## `rooms` (type: `integer`):

Number of rooms to record with the run. Public Trivago SEO listing pages may not expose room-specific live pricing.

## `currency` (type: `string`):

Optional preferred currency code such as USD, EUR, or GBP. Trivago decides which currency is visible on the public page; the output includes the actual visible currency when available.

## `maxResults` (type: `integer`):

Maximum number of public hotel listing cards to return. Trivago destination pages commonly expose up to 35 public listing cards in the initial SEO page.

## `includePrices` (type: `boolean`):

Include public visible price fields when Trivago exposes them on listing cards.

## `includeBookingProviders` (type: `boolean`):

Include public provider count and provider fields when visible. Trivago listing pages often expose provider counts, not individual provider names.

## `includeImages` (type: `boolean`):

Include public hotel image URLs when available.

## `includeRatings` (type: `boolean`):

Include public guest rating, review count, and star rating fields when available.

## `includeAmenities` (type: `boolean`):

Include public listing highlights and amenity-like text when visible on the listing card.

## `deduplicateResults` (type: `boolean`):

Remove duplicate hotels using Trivago accommodation IDs and URLs.

## `maxRetries` (type: `integer`):

Number of retry attempts for destination resolution and public listing page requests.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for each public Trivago request.

## `languageCode` (type: `string`):

Trivago locale path used for public destination resolution.

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

Proxy settings for public Trivago pages. Residential proxies are recommended for cloud runs if Trivago blocks datacenter traffic.

## `debugMode` (type: `boolean`):

Save debug HTML and parsed state to the key-value store when no listings are found or a request is blocked.

## Actor input object example

```json
{
  "destination": "Amsterdam",
  "checkIn": "2026-07-01",
  "checkOut": "2026-07-02",
  "adults": 2,
  "rooms": 1,
  "currency": "EUR",
  "maxResults": 100,
  "includePrices": true,
  "includeBookingProviders": true,
  "includeImages": true,
  "includeRatings": true,
  "includeAmenities": true,
  "deduplicateResults": true,
  "maxRetries": 3,
  "requestTimeoutSecs": 45,
  "languageCode": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debugMode": false
}
```

# Actor output Schema

## `hotels` (type: `string`):

Clean public Trivago hotel listing records for hotel research, price comparison, and lead-generation workflows.

# 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 = {
    "destination": "Amsterdam",
    "adults": 2,
    "rooms": 1,
    "maxResults": 100,
    "includePrices": true,
    "includeBookingProviders": true,
    "includeImages": true,
    "includeRatings": true,
    "includeAmenities": true,
    "deduplicateResults": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("esrok/trivago-hotel-scraper-lead-finder").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 = {
    "destination": "Amsterdam",
    "adults": 2,
    "rooms": 1,
    "maxResults": 100,
    "includePrices": True,
    "includeBookingProviders": True,
    "includeImages": True,
    "includeRatings": True,
    "includeAmenities": True,
    "deduplicateResults": True,
}

# Run the Actor and wait for it to finish
run = client.actor("esrok/trivago-hotel-scraper-lead-finder").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 '{
  "destination": "Amsterdam",
  "adults": 2,
  "rooms": 1,
  "maxResults": 100,
  "includePrices": true,
  "includeBookingProviders": true,
  "includeImages": true,
  "includeRatings": true,
  "includeAmenities": true,
  "deduplicateResults": true
}' |
apify call esrok/trivago-hotel-scraper-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=esrok/trivago-hotel-scraper-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trivago Hotel Scraper and Lead Finder",
        "description": "Extract public Trivago hotel listings, visible prices, ratings, review counts, provider counts, images, and hotel metadata for travel research, price comparison, market analysis, and B2B lead-generation workflows.",
        "version": "1.0",
        "x-build-id": "PiY5j77OctVnOqh7R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/esrok~trivago-hotel-scraper-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-esrok-trivago-hotel-scraper-lead-finder",
                "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/esrok~trivago-hotel-scraper-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-esrok-trivago-hotel-scraper-lead-finder",
                "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/esrok~trivago-hotel-scraper-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-esrok-trivago-hotel-scraper-lead-finder",
                "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": [
                    "destination",
                    "maxResults"
                ],
                "properties": {
                    "destination": {
                        "title": "Destination",
                        "minLength": 2,
                        "type": "string",
                        "description": "City, region, country, landmark, or a public Trivago destination URL. Examples: Amsterdam, London, Paris, Barcelona."
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Optional check-in date in YYYY-MM-DD format. The Actor returns this value in each row for downstream workflows. Trivago public listing pages may still show forecasted public prices instead of exact stay-date prices."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Optional check-out date in YYYY-MM-DD format. Must be after the check-in date when both are provided."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of adult guests to record with the run. Public Trivago SEO listing pages may not expose guest-specific live pricing.",
                        "default": 2
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of rooms to record with the run. Public Trivago SEO listing pages may not expose room-specific live pricing.",
                        "default": 1
                    },
                    "currency": {
                        "title": "Preferred currency",
                        "type": "string",
                        "description": "Optional preferred currency code such as USD, EUR, or GBP. Trivago decides which currency is visible on the public page; the output includes the actual visible currency when available."
                    },
                    "maxResults": {
                        "title": "Maximum hotel listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of public hotel listing cards to return. Trivago destination pages commonly expose up to 35 public listing cards in the initial SEO page.",
                        "default": 100
                    },
                    "includePrices": {
                        "title": "Include prices",
                        "type": "boolean",
                        "description": "Include public visible price fields when Trivago exposes them on listing cards.",
                        "default": true
                    },
                    "includeBookingProviders": {
                        "title": "Include booking provider data",
                        "type": "boolean",
                        "description": "Include public provider count and provider fields when visible. Trivago listing pages often expose provider counts, not individual provider names.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Include images",
                        "type": "boolean",
                        "description": "Include public hotel image URLs when available.",
                        "default": true
                    },
                    "includeRatings": {
                        "title": "Include ratings",
                        "type": "boolean",
                        "description": "Include public guest rating, review count, and star rating fields when available.",
                        "default": true
                    },
                    "includeAmenities": {
                        "title": "Include amenities and highlights",
                        "type": "boolean",
                        "description": "Include public listing highlights and amenity-like text when visible on the listing card.",
                        "default": true
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate results",
                        "type": "boolean",
                        "description": "Remove duplicate hotels using Trivago accommodation IDs and URLs.",
                        "default": true
                    },
                    "maxRetries": {
                        "title": "Maximum retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for destination resolution and public listing page requests.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum seconds to wait for each public Trivago request.",
                        "default": 45
                    },
                    "languageCode": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Trivago locale path used for public destination resolution.",
                        "default": "en-US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for public Trivago pages. Residential proxies are recommended for cloud runs if Trivago blocks datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Save debug HTML and parsed state to the key-value store when no listings are found or a request is blocked.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
