# Willhaben Scraper | Marketplace, Real Estate, Cars & Jobs (`solidcode/willhaben-scraper`) Actor

\[💰 $0.85 / 1K] Scrape willhaben.at — Austria's largest classifieds marketplace. Extract listings with prices, descriptions, seller info, images, and section-specific details for marketplace goods, real estate, cars, and jobs. Search by URL or plain-text terms.

- **URL**: https://apify.com/solidcode/willhaben-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Real estate, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Willhaben Scraper

Pull listings from willhaben.at at scale — marketplace goods, real estate, cars, and jobs — with prices, GPS coordinates, full addresses, images, publish dates, and vertical-specific details on every row. Search by plain-text terms or paste any willhaben.at URL, and get one clean, structured row per listing across all four sections of Austria's largest classifieds marketplace. Built for Austrian market researchers, car dealers, real-estate analysts, and recruiters who need fresh willhaben data without manual copy-paste or hand-crafting search links.

### Why This Scraper?

- **All 4 willhaben verticals in one actor** — marketplace goods (Marktplatz), real estate (Immobilien), cars (Auto & Motor), and jobs, auto-detected from the section you choose or the URL you paste.
- **Plain-text search, no URL crafting** — type "iPhone 15 Pro", "Wohnung Wien", or "BMW 3er" and pick a section, instead of hand-building willhaben.at links.
- **One global result cap, no surprise bills** — `maxResults` is a single total across every URL and search term combined, so two searches at 100 never silently balloon to 200.
- **GPS coordinates + full address on every listing** — latitude, longitude, city, postal code, district, and region, ready to map or geo-filter.
- **Car specs out of the box** — make, model, registration year, mileage in km, fuel type, transmission, power in kW and PS, condition, and previous-owner count, all resolved to readable German values (not raw codes).
- **Real-estate detail fields** — living area and plot area in m², room count, floor, price per m², gross rent, object type, and buy-vs-rent transaction type.
- **Jobs with embedded company data** — salary and pay cadence, employment modes (Vollzeit/Teilzeit), job locations, and a nested company object with name, logo, and willhaben company ID.
- **Native price band + 4 sort orders** — filter by minimum and maximum euro price and sort by newest, price low-to-high, price high-to-low, or relevance, all applied at the source.
- **Clean camelCase output** — readable field names with empty values stripped; no raw screaming-snake attribute keys or display-widget noise polluting your dataset.

### Use Cases

**Market Research**
- Track asking prices for any product across the whole Austrian marketplace
- Map inventory by city, postal code, or region using built-in coordinates
- Compare listing volume and pricing between Vienna, Graz, Linz, and Salzburg
- Monitor how long goods, cars, or properties stay listed by publish date

**Price Monitoring**
- Build price-band watchlists with minimum and maximum euro filters
- Compare price per m² across real-estate neighborhoods
- Track used-car pricing by make, model, mileage, and registration year
- Detect underpriced listings the moment they appear with newest-first sorting

**Car Dealer Intelligence**
- Pull competitor inventory with full specs (mileage, fuel, power, condition)
- Identify private-seller vs. dealer listings by seller type
- Benchmark resale prices for a make/model across the country
- Spot fresh trade-in opportunities sorted by newest

**Real-Estate Analysis**
- Aggregate rent and buy listings with living area, rooms, and price per m²
- Map property supply by district and postal code
- Separate rental and purchase markets with the transaction type field
- Feed comparable-listing data into valuation models

**Recruitment Intelligence**
- Build job-market datasets with salary, employment mode, and location
- Track which companies are hiring and where, via the embedded company object
- Monitor open roles by keyword and region for talent sourcing
- Compare advertised salaries across employers and job titles

### Getting Started

#### Simple Search

Type a search term and pick a section — that's it:

```json
{
    "searchQueries": ["iphone"],
    "category": "marktplatz",
    "maxResults": 100
}
````

#### Filtered Car Search

Narrow a vehicle search by price and sort by newest:

```json
{
    "searchQueries": ["BMW 3er"],
    "category": "auto",
    "minPrice": 5000,
    "maxPrice": 25000,
    "sortBy": "newest",
    "maxResults": 200
}
```

#### Paste a willhaben URL

Apply filters on willhaben.at, copy the URL from your browser, and reuse every facet:

```json
{
    "startUrls": [
        "https://www.willhaben.at/iad/immobilien/mietwohnungen/wien"
    ],
    "maxResults": 150
}
```

#### Full-Featured Example

Combine URLs and search terms in one run:

```json
{
    "startUrls": [
        "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=macbook"
    ],
    "searchQueries": ["Wohnung Wien", "software"],
    "category": "immobilien",
    "minPrice": 100,
    "maxPrice": 2000,
    "sortBy": "price_asc",
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | One or more willhaben.at search, category, or result-list URLs. Apply your filters on the site, then paste the browser URL. Works for any section. |
| `searchQueries` | string\[] | `[]` | Plain-text search terms (e.g. "iPhone 15 Pro", "Wohnung Wien", "BMW 3er"). Searched in the section chosen below. |
| `category` | select | `Marketplace (goods)` | Which section your search terms apply to: Marketplace, Real Estate, Cars & Motors, or Jobs. Only affects `searchQueries` — URLs carry their own section. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum total listings across all URLs and search terms combined. Set to 0 for no limit. Start with 50–100 to test, then scale up. |
| `sortBy` | select | `Newest First` | Order results are collected in: Newest First, Price Low to High, Price High to Low, or Most Relevant. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | — | Only include listings priced at or above this amount in euros. Applies to sections with prices (marketplace, real estate, cars). |
| `maxPrice` | integer | — | Only include listings priced at or below this amount in euros. Applies to sections with prices (marketplace, real estate, cars). |

### Output

Each listing is one flat row. Common fields appear on every result; section-specific fields populate for real estate, cars, and jobs. Here's a representative marketplace result:

```json
{
    "listingId": "1820394756",
    "category": "marktplatz",
    "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/d/apple-iphone-15-pro-256gb-1820394756/",
    "title": "Apple iPhone 15 Pro 256GB Titan",
    "description": "Top-Zustand, mit Originalverpackung und Rechnung.",
    "price": 899,
    "priceText": "899 €",
    "currency": "EUR",
    "publishedAt": "2026-05-27T09:14:00Z",
    "updatedAt": "2026-05-28T11:02:00Z",
    "sellerName": "Max M.",
    "sellerType": "private",
    "city": "Wien",
    "postalCode": "1100",
    "district": "Favoriten",
    "region": "Wien",
    "country": "Österreich",
    "latitude": 48.1734,
    "longitude": 16.3782,
    "imageUrls": ["https://cache.willhaben.at/mmo/example1.jpg"],
    "scrapedAt": "2026-05-29T14:30:00Z"
}
```

#### Core Fields (all sections)

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique willhaben ad ID |
| `category` | string | Section: marktplatz, immobilien, auto, or jobs |
| `url` | string | Canonical listing URL |
| `title` | string | Listing headline |
| `description` | string | Listing body text |
| `price` | number | Numeric price in EUR (null for jobs) |
| `priceText` | string | Display price string as shown on willhaben |
| `currency` | string | Currency code (EUR) |
| `sellerName` | string | Seller or advertiser name |
| `sellerType` | string | private or dealer |
| `publishedAt` | string | First publish date (ISO 8601) |
| `updatedAt` | string | Last modified date (ISO 8601) |
| `imageUrls` | string\[] | Listing image URLs |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City or town |
| `postalCode` | string | Austrian postal code |
| `district` | string | District name |
| `region` | string | Federal state |
| `country` | string | Country |
| `latitude` | number | Latitude coordinate |
| `longitude` | number | Longitude coordinate |

#### Real Estate (immobilien)

| Field | Type | Description |
|-------|------|-------------|
| `transactionType` | string | rent or buy (derived from the listing path) |
| `objectType` | string | Property type (apartment, house, etc.) |
| `livingAreaM2` | number | Living area in m² |
| `plotAreaM2` | number | Plot area in m² |
| `roomCount` | number | Number of rooms |
| `floor` | string | Floor |
| `rentGross` | number | Gross monthly rent |
| `pricePerM2` | number | Price per square meter |
| `street` | string | Street address |

#### Cars & Motors (auto)

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Vehicle make |
| `model` | string | Vehicle model |
| `yearBuilt` | number | First registration year |
| `mileageKm` | number | Mileage in kilometers |
| `fuelType` | string | Fuel type (resolved, e.g. "Benzin", "Diesel") |
| `transmission` | string | Transmission (resolved, e.g. "Schaltgetriebe") |
| `powerKw` | number | Engine power in kW |
| `powerPs` | number | Engine power in PS |
| `condition` | string | Condition (resolved, e.g. "Gebrauchtwagen") |
| `ownerCount` | number | Number of previous owners |

#### Jobs (jobs)

| Field | Type | Description |
|-------|------|-------------|
| `position` | string | Role or seniority level |
| `salary` | number | Advertised salary |
| `salaryTimeFrame` | string | Salary cadence (e.g. monthly, yearly) |
| `employmentModes` | string\[] | Employment modes (Vollzeit, Teilzeit, etc.) |
| `jobLocations` | object\[] | Job locations with name, federal state, and country |
| `company` | object | Hiring company: id, title, slugTitle, logoUrl |

### Tips for Best Results

- **Start small** — set `maxResults` to 50–100 on your first run to confirm the data matches your needs, then scale up.
- **Paste a fully-filtered URL** — apply every facet you want on willhaben.at (location, sub-category, attributes), then copy the browser URL into `startUrls`; the scraper reuses all of those filters automatically, including ones not exposed as inputs here.
- **Pick the right section** — `category` only steers your plain-text search terms. To search cars, set it to "Cars & Motors"; the same word in "Marketplace" returns very different results.
- **The jobs section has no price** — job listings carry salary instead of price, and price sorting falls back to newest. Use the price band only for marketplace, real estate, and cars.
- **Combine inputs in one run** — mix several URLs and search terms together; the global `maxResults` cap covers all of them so you never overspend.
- **Use newest-first for monitoring** — schedule a recurring run sorted by newest to catch fresh listings the moment they appear.
- **Derive rent vs. buy from URLs** — real-estate `transactionType` fills in reliably when you paste a rental (`mietwohnungen`) or purchase URL; generic plain-text property searches can't tell the two apart.

### Pricing

**$0.85 per 1,000 results** — undercuts comparable willhaben scrapers while giving you a single, predictable result cap.

| Results | Price |
|---------|-------|
| 100 | $0.09 |
| 1,000 | $0.85 |
| 10,000 | $8.50 |
| 100,000 | $85.00 |

A "result" is any listing row in the output dataset. No compute charges — you only pay per result returned. Apify platform fees (storage) depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, price monitoring, lead generation, and recruitment analysis. Users are responsible for complying with applicable laws and willhaben.at's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with GDPR and Austrian data-protection law.

# Actor input Schema

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

Paste one or more willhaben.at search, category, or result-list URLs. Tip: apply the filters you want on the willhaben.at website, then copy the URL from your browser. Works for any section — marketplace, real estate, cars, or jobs.

## `searchQueries` (type: `array`):

Plain-text search terms — for example 'iPhone 15 Pro', 'Wohnung Wien', or 'BMW 3er'. The scraper searches willhaben.at in the section you choose below and returns matching listings.

## `category` (type: `string`):

Which section of willhaben.at your search terms apply to. Only affects the plain-text Search Terms above — URLs already include their own section.

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

Maximum total number of listings to collect across all URLs and search terms combined. Set to 0 for no limit (up to a 100,000 safety ceiling).

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

Choose the order in which listings are collected from willhaben.at.

## `minPrice` (type: `integer`):

Only include listings priced at or above this amount in euros. Leave empty for no minimum. Applies to sections that have prices (marketplace, real estate, cars).

## `maxPrice` (type: `integer`):

Only include listings priced at or below this amount in euros. Leave empty for no maximum. Applies to sections that have prices (marketplace, real estate, cars).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
  ],
  "searchQueries": [],
  "category": "marktplatz",
  "maxResults": 100,
  "sortBy": "newest"
}
```

# Actor output Schema

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

Table of scraped listings with key fields.

## `details` (type: `string`):

All fields including seller info, location, and section-specific attributes.

# 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 = {
    "startUrls": [
        "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
    ],
    "searchQueries": [],
    "category": "marktplatz",
    "maxResults": 100,
    "sortBy": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/willhaben-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 = {
    "startUrls": ["https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"],
    "searchQueries": [],
    "category": "marktplatz",
    "maxResults": 100,
    "sortBy": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/willhaben-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 '{
  "startUrls": [
    "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
  ],
  "searchQueries": [],
  "category": "marktplatz",
  "maxResults": 100,
  "sortBy": "newest"
}' |
apify call solidcode/willhaben-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Willhaben Scraper | Marketplace, Real Estate, Cars & Jobs",
        "description": "[💰 $0.85 / 1K] Scrape willhaben.at — Austria's largest classifieds marketplace. Extract listings with prices, descriptions, seller info, images, and section-specific details for marketplace goods, real estate, cars, and jobs. Search by URL or plain-text terms.",
        "version": "1.0",
        "x-build-id": "nu8xFCYOrXricmfug"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~willhaben-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-willhaben-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/solidcode~willhaben-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-willhaben-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/solidcode~willhaben-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-willhaben-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": {
                    "startUrls": {
                        "title": "Willhaben URLs",
                        "type": "array",
                        "description": "Paste one or more willhaben.at search, category, or result-list URLs. Tip: apply the filters you want on the willhaben.at website, then copy the URL from your browser. Works for any section — marketplace, real estate, cars, or jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Plain-text search terms — for example 'iPhone 15 Pro', 'Wohnung Wien', or 'BMW 3er'. The scraper searches willhaben.at in the section you choose below and returns matching listings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Search Section",
                        "enum": [
                            "marktplatz",
                            "immobilien",
                            "auto",
                            "jobs"
                        ],
                        "type": "string",
                        "description": "Which section of willhaben.at your search terms apply to. Only affects the plain-text Search Terms above — URLs already include their own section.",
                        "default": "marktplatz"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of listings to collect across all URLs and search terms combined. Set to 0 for no limit (up to a 100,000 safety ceiling).",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "newest",
                            "price_asc",
                            "price_desc",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Choose the order in which listings are collected from willhaben.at.",
                        "default": "newest"
                    },
                    "minPrice": {
                        "title": "Minimum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or above this amount in euros. Leave empty for no minimum. Applies to sections that have prices (marketplace, real estate, cars)."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or below this amount in euros. Leave empty for no maximum. Applies to sections that have prices (marketplace, real estate, cars)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```