# Willhaben.at Marketplace Scraper (`automation-lab/willhaben-at-marketplace-scraper`) Actor

Scrape public Willhaben.at marketplace listings with prices, locations, seller IDs, images, timestamps, and source search context.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Willhaben.at Marketplace Scraper

Extract public marketplace listings from Willhaben.at by keyword or copied search URL.

The actor reads the server-rendered search data embedded in Willhaben.at pages and saves clean dataset rows with listing URLs, prices, locations, seller identifiers, images, timestamps, and raw attributes.

### What does Willhaben.at Marketplace Scraper do?

Willhaben.at Marketplace Scraper collects classifieds marketplace listings from public Willhaben.at search result pages.

Use it to scrape Austrian marketplace data without manually copying results from the website.

The actor supports:

- 🔎 Keyword searches such as `iphone`, `fahrrad`, or `macbook`
- 🔗 Full Willhaben.at marketplace search URLs copied from your browser
- 📄 Pagination through search result pages
- 💶 Price and displayed price extraction
- 📍 Austrian location, postcode, state, district, and coordinate fields
- 🖼️ Main image and all image URLs exposed in the public listing summary
- 🧾 Seller organization IDs and UUIDs when available
- ⏱️ Published, changed, and end timestamps
- 🧩 Raw Willhaben attributes for custom downstream mapping

### Who is it for?

This actor is useful for teams that need repeatable Austrian classifieds data.

Typical users include:

- 🛒 Resellers monitoring supply and resale prices
- 📊 Ecommerce analysts benchmarking second-hand goods
- 🏷️ Price intelligence teams tracking local Austrian inventory
- 🧰 Marketplace aggregators enriching product feeds
- 🧑‍💼 Lead generation teams finding sellers in specific categories
- 🧪 Data teams building historical listing datasets
- 📦 Retail teams watching competitor liquidation or used inventory

### Why use this actor?

Willhaben.at is one of Austria's largest classifieds marketplaces.

Manual monitoring is slow, inconsistent, and hard to scale.

This actor gives you structured output that can be exported, scheduled, filtered, or sent to other Apify integrations.

### What data can you extract?

The default dataset contains one row per marketplace listing.

| Field | Description |
| --- | --- |
| `id` | Willhaben listing ID |
| `adUuid` | Listing UUID when exposed |
| `url` | Public listing URL |
| `title` | Listing title |
| `description` | Summary/body text from search data |
| `price` | Numeric price when available |
| `priceDisplay` | Display price such as `€ 10` |
| `currency` | Currency, usually `EUR` |
| `location` | Human-readable location |
| `district` | District or city area |
| `postcode` | Austrian postcode |
| `state` | Austrian state |
| `country` | Country value from Willhaben |
| `latitude` / `longitude` | Coordinates when present |
| `sellerOrgId` | Seller organization ID |
| `sellerOrgUuid` | Seller organization UUID |
| `isPrivate` | Whether the listing appears private |
| `advertStatus` | Listing status |
| `categoryTreeIds` | Category IDs from Willhaben |
| `imageUrl` | Main image URL |
| `imageUrls` | All image URLs exposed in search data |
| `publishedAt` | Publication timestamp |
| `changedAt` | Last changed timestamp |
| `endsAt` | Listing end timestamp |
| `sourceSearchUrl` | Search URL that produced the row |
| `searchKeyword` | Keyword input when used |
| `searchPage` | Result page number |
| `searchRowsFound` | Total rows found reported by Willhaben |
| `rawAttributes` | Raw name/value attributes from Willhaben |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape Willhaben.at marketplace listings?

This actor uses pay-per-event pricing.

You pay a small start event and a per-listing result event.

The exact live prices are visible on the Apify Store pricing tab before you run the actor.

Use a low `maxItems` value for first tests, then increase it once the output fits your workflow.

### Input options

You can provide keywords, search URLs, or both.

#### Keywords

Add one or more Willhaben marketplace keywords.

Example:

```json
{
  "keywords": ["iphone", "macbook"],
  "maxItems": 100
}
````

#### Search URLs

Copy a marketplace search URL from Willhaben.at and paste it into `searchUrls`.

This is useful when you already applied filters on the website.

```json
{
  "searchUrls": [
    { "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone" }
  ],
  "maxItems": 100
}
```

### Output example

```json
{
  "id": "2126473074",
  "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/d/no-name-kophoerer-2126473074/",
  "title": "No-Name-Kophörer",
  "price": 10,
  "priceDisplay": "€ 10",
  "location": "Wien, 11. Bezirk, Simmering",
  "postcode": "1110",
  "state": "Wien",
  "country": "Österreich",
  "sellerOrgId": "32996024",
  "publishedAt": "2026-07-10T04:05:00Z",
  "sourceSearchUrl": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone",
  "searchPage": 1,
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
```

### How to scrape Willhaben.at marketplace listings

1. Open the actor on Apify.
2. Add one or more keywords, or paste Willhaben.at marketplace search URLs.
3. Set `maxItems` to the number of listings you need.
4. Keep `rowsPerPage` at the default unless you need smaller page requests.
5. Run the actor.
6. Download results as JSON, CSV, Excel, XML, or RSS.
7. Schedule the actor if you need recurring monitoring.

### Tips for better results

- Use German product names for broader Austrian coverage.
- Use exact model names for high-intent price monitoring.
- Paste filtered URLs when you need a specific category or region.
- Start with 30 to 100 items during setup.
- Increase `maxItems` for recurring inventory monitoring.
- Keep duplicate handling in your downstream system by listing `id`.

### Pagination and limits

Willhaben search pages currently expose multiple rows in the initial HTML.

The actor requests up to 90 rows per page and continues through pages until it reaches `maxItems` or no more results are available.

The `searchRowsFound` field records the total result count reported by Willhaben for each search page.

### Proxy and anti-blocking

Public marketplace pages are currently accessible with normal HTTP requests.

The actor does not use Apify Proxy by default.

Enable `useApifyProxy` if you run higher-volume jobs or if your network receives temporary blocks.

For large scheduled monitoring, consider moderate run sizes and reasonable schedule frequency.

### Integrations

You can connect the dataset to many workflows:

- 📈 Send listing data to Google Sheets for price tracking
- 🧊 Export to Snowflake, BigQuery, or S3 for historical analysis
- 🔔 Use webhooks to trigger alerts for new matching listings
- 🧹 Deduplicate rows by `id` in your database
- 🤖 Feed current classifieds prices into internal resale models
- 🧑‍💻 Call the actor from backend services using the Apify API

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/willhaben-at-marketplace-scraper').call({
  keywords: ['iphone'],
  maxItems: 100,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/willhaben-at-marketplace-scraper').call(run_input={
    'keywords': ['iphone'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~willhaben-at-marketplace-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["iphone"],"maxItems":100}'
```

### MCP usage

Use this actor through the Apify MCP server in Claude tools.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/willhaben-at-marketplace-scraper
```

Claude Code setup:

```bash
claude mcp add apify-willhaben "https://mcp.apify.com/?tools=automation-lab/willhaben-at-marketplace-scraper"
```

JSON configuration for MCP clients:

```json
{
  "mcpServers": {
    "apify-willhaben": {
      "url": "https://mcp.apify.com/?tools=automation-lab/willhaben-at-marketplace-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Willhaben iPhone marketplace listings and summarize median prices by Austrian state."
- "Find recent Willhaben bicycle listings and return listing URLs, prices, and postcodes."
- "Monitor Willhaben for PlayStation 5 listings and highlight unusually low prices."

### Scheduling

Schedule the actor daily or hourly to build a monitoring feed.

For recurring jobs, keep the same keyword or URL inputs and compare new dataset rows by `id`.

### Data quality notes

The actor extracts data exposed in Willhaben search result JSON.

Some listings may not include prices, coordinates, images, or seller identifiers.

Optional fields are omitted when the source page does not expose them.

### Legality

This actor extracts public marketplace information.

You are responsible for using the data lawfully and respecting applicable terms, privacy rules, and local regulations.

Avoid collecting personal data you do not need.

Use reasonable run sizes and schedules.

### FAQ and troubleshooting

#### The actor returned fewer items than expected

Willhaben may report fewer available listings for a narrow query, filtered URL, or page range.

Try a broader keyword or inspect `searchRowsFound`.

#### I see no price for some listings

Some Willhaben listings may be negotiable, free, or missing a numeric price in the public search data.

Use `priceDisplay` and `rawAttributes` for additional context.

#### My URL does not work

Use public marketplace search URLs under `/iad/kaufen-und-verkaufen/marktplatz`.

Other Willhaben verticals such as cars, jobs, or real estate are outside this actor's MVP scope.

### Related scrapers

Explore other automation-lab actors for marketplace, ecommerce, and lead workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/booking-scraper

### Changelog

See the actor changelog for release notes.

### Support

If a run fails, open an issue with the run URL and your input JSON.

We use those details to reproduce and fix problems quickly.

# Actor input Schema

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

Marketplace search keywords to scrape on Willhaben.at. Use German terms or product names exactly as buyers search for them.

## `searchUrls` (type: `array`):

Full public Willhaben.at marketplace search result URLs. Useful for category, filter, or location searches copied from your browser.

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

Maximum number of marketplace listing records to save across all keywords and URLs.

## `rowsPerPage` (type: `integer`):

Number of listings requested per Willhaben search page. The actor caps this at 90, which the public site currently supports.

## `useApifyProxy` (type: `boolean`):

Enable Apify Proxy if you run higher-volume jobs or your network receives temporary blocks. Disabled by default because public pages are accessible over HTTP.

## Actor input object example

```json
{
  "keywords": [
    "iphone"
  ],
  "searchUrls": [
    {
      "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
    }
  ],
  "maxItems": 20,
  "rowsPerPage": 90,
  "useApifyProxy": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "iphone"
    ],
    "searchUrls": [
        {
            "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
        }
    ],
    "maxItems": 20,
    "rowsPerPage": 90,
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/willhaben-at-marketplace-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["iphone"],
    "searchUrls": [{ "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone" }],
    "maxItems": 20,
    "rowsPerPage": 90,
    "useApifyProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/willhaben-at-marketplace-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "iphone"
  ],
  "searchUrls": [
    {
      "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/marktplatz?keyword=iphone"
    }
  ],
  "maxItems": 20,
  "rowsPerPage": 90,
  "useApifyProxy": false
}' |
apify call automation-lab/willhaben-at-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Willhaben.at Marketplace Scraper",
        "description": "Scrape public Willhaben.at marketplace listings with prices, locations, seller IDs, images, timestamps, and source search context.",
        "version": "0.1",
        "x-build-id": "XSYta0rZBaZdf8gb5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~willhaben-at-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-willhaben-at-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~willhaben-at-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-willhaben-at-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~willhaben-at-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-willhaben-at-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Marketplace search keywords to scrape on Willhaben.at. Use German terms or product names exactly as buyers search for them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Willhaben marketplace search URLs",
                        "type": "array",
                        "description": "Full public Willhaben.at marketplace search result URLs. Useful for category, filter, or location searches copied from your browser.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of marketplace listing records to save across all keywords and URLs.",
                        "default": 100
                    },
                    "rowsPerPage": {
                        "title": "Rows per page",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Number of listings requested per Willhaben search page. The actor caps this at 90, which the public site currently supports.",
                        "default": 90
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy if you run higher-volume jobs or your network receives temporary blocks. Disabled by default because public pages are accessible over HTTP.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```