# Marktplaats Netherlands Classifieds Scraper (`automation-lab/marktplaats-netherlands-classifieds-scraper`) Actor

Extract public Marktplaats.nl listings with prices, sellers, locations, attributes, images, and URLs for Dutch marketplace monitoring.

- **URL**: https://apify.com/automation-lab/marktplaats-netherlands-classifieds-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, NaN 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

## Marktplaats Netherlands Classifieds Scraper

Extract structured listings from Marktplaats.nl category and search result pages.

Use this actor to collect Dutch marketplace data with listing URLs, titles, descriptions, prices, seller names, locations, category-specific attributes, image URLs, promoted flags, and scrape timestamps.

### What does this Marktplaats scraper do?

The Marktplaats Netherlands Classifieds Scraper turns public Marktplaats result pages into a clean dataset.

It accepts Marktplaats category or search URLs and follows pagination until it reaches your limits.

Typical pages include car listings, bikes, furniture, electronics, home goods, tools, and other public classifieds categories.

The actor is HTTP-based and reads the structured listing data embedded in the page.

That keeps runs lightweight, fast, and affordable compared with browser automation.

### Who is it for?

- 🚗 Used-car dealers monitoring Dutch car inventory and prices.
- 🛍️ Resellers tracking popular second-hand product categories.
- 📊 Marketplace analysts building regional pricing benchmarks.
- 🏠 Local commerce teams watching supply in Dutch cities.
- 🔎 Researchers studying classified ad trends.
- 🤖 Automation teams feeding Marktplaats data into dashboards, alerts, and enrichment workflows.

### Why use this actor?

Marktplaats pages are designed for people, not spreadsheets.

This actor extracts the important listing fields into JSON, CSV, Excel, or any dataset export supported by Apify.

You can run small checks from the Apify Console or schedule recurring jobs for monitoring.

You can also call the actor from code and connect the dataset to your own BI or data pipeline.

### What data can I extract from Marktplaats?

The actor saves one dataset item per listing.

| Field | Description |
| --- | --- |
| `listingId` | Marktplaats listing identifier |
| `listingUrl` | Public listing URL |
| `title` | Listing title |
| `shortTitle` | Short or category title when available |
| `description` | Listing snippet or category-specific description |
| `price` | Price in euros when available |
| `priceCents` | Raw price in euro cents |
| `currency` | Currency code, usually `EUR` |
| `priceType` | Price type such as fixed or sale/rent label |
| `city` | Seller/listing city |
| `country` | Listing country |
| `latitude` / `longitude` | Coordinates when included in public data |
| `sellerName` | Seller display name |
| `sellerId` | Seller identifier when public |
| `sellerVerified` | Seller verification flag when public |
| `date` | Marktplaats date label |
| `imageUrls` | Listing image URLs |
| `attributes` | Category-specific attributes such as mileage, fuel, size, or condition |
| `traits` | Marktplaats listing traits/promotions |
| `sourceUrl` | Result page where the item was found |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Marktplaats classifieds?

This actor uses pay-per-event pricing.

There is a $0.005 run-start event and a tiered per-listing event.

Bronze per-listing price is $0.00010275, with standard Apify tier discounts for Silver, Gold, Platinum, and Diamond users.

Small test runs are inexpensive when you keep `maxItems` and `maxPagesPerUrl` low.

For a first run, use the prefilled car category URL with 20 listings and 3 pages.

### How to use it

1. Open the actor on Apify.
2. Paste one or more Marktplaats search/category URLs.
3. Set `maxItems` to the number of listings you need.
4. Set `maxPagesPerUrl` as a pagination safety cap.
5. Keep `includeAttributes` enabled if you want category-specific specs.
6. Start the run.
7. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.marktplaats.nl/l/auto-s/" }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 3,
  "includeAttributes": true
}
````

### Input fields

#### `startUrls`

Marktplaats result pages to scrape.

Use public category URLs such as `https://www.marktplaats.nl/l/auto-s/`.

Use public search URLs such as `https://www.marktplaats.nl/q/fiets/`.

#### `maxItems`

Maximum number of listings to save across all URLs.

#### `maxPagesPerUrl`

Maximum number of paginated result pages to visit for each URL.

#### `includeAttributes`

When enabled, the actor saves raw category-specific attributes.

For cars, attributes can include mileage, year, fuel, transmission, and body type.

For other categories, attributes vary by Marktplaats category.

### Output example

```json
{
  "listingId": "m2396885553",
  "listingUrl": "https://www.marktplaats.nl/v/auto-s/fiat/m2396885553-fiat-panda-twinair-85-2012-zwart-zeer-zuinig",
  "title": "Fiat Panda Twinair 85 2012 Zwart, zeer zuinig",
  "price": 2750,
  "currency": "EUR",
  "city": "Soest",
  "country": "Nederland",
  "sellerName": "Tom",
  "date": "Vandaag",
  "imageUrls": ["https://images.marktplaats.com/..."],
  "sourceUrl": "https://www.marktplaats.nl/l/auto-s/",
  "scrapedAt": "2026-05-22T12:00:00.000Z"
}
```

### Tips for best results

- ✅ Start with one category URL and a low item limit.
- ✅ Use specific Marktplaats search URLs for narrow monitoring.
- ✅ Increase `maxPagesPerUrl` only when you need deeper pagination.
- ✅ Keep `includeAttributes` on for cars, real estate, electronics, and other spec-heavy categories.
- ✅ Schedule recurring runs for price tracking and inventory monitoring.

### Integrations

You can connect the output dataset to many workflows:

- 📈 Send prices to Google Sheets or Airtable.
- 🧭 Build dashboards in Looker Studio, Power BI, or Metabase.
- 🔔 Trigger alerts when new listings appear in a category.
- 🧹 Deduplicate listings by `listingId` in your data warehouse.
- 🤝 Enrich leads with internal CRM data.
- 🧪 Compare Marktplaats prices with other classified marketplaces.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/marktplaats-netherlands-classifieds-scraper').call({
  startUrls: [{ url: 'https://www.marktplaats.nl/l/auto-s/' }],
  maxItems: 20,
  maxPagesPerUrl: 3,
  includeAttributes: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/marktplaats-netherlands-classifieds-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.marktplaats.nl/l/auto-s/'}],
    'maxItems': 20,
    'maxPagesPerUrl': 3,
    'includeAttributes': True,
})

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

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~marktplaats-netherlands-classifieds-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.marktplaats.nl/l/auto-s/"}],
    "maxItems": 20,
    "maxPagesPerUrl": 3,
    "includeAttributes": true
  }'
```

### MCP integration

Use this actor through the Apify MCP server in AI tools that support MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/marktplaats-netherlands-classifieds-scraper
```

Claude Code setup:

```bash
claude mcp add apify-marktplaats https://mcp.apify.com/?tools=automation-lab/marktplaats-netherlands-classifieds-scraper
```

Generic MCP JSON config:

```json
{
  "mcpServers": {
    "apify-marktplaats": {
      "url": "https://mcp.apify.com/?tools=automation-lab/marktplaats-netherlands-classifieds-scraper"
    }
  }
}
```

Example prompt ideas for Claude Code or Claude Desktop:

- "Use the Apify Marktplaats scraper to scrape 30 car listings and summarize the price range."
- "Run the Marktplaats tool for this bike search URL and return listing IDs, prices, and seller cities."
- "Use the MCP dataset output to compare seller cities from the latest Marktplaats run."
- "Find the cheapest listings from this Marktplaats category and export the result as a table."

### Scheduling

Apify schedules can run this scraper hourly, daily, weekly, or monthly.

For monitoring, keep the same search URL and compare new `listingId` values between runs.

For pricing trends, store historical `price` values by `listingId` and `scrapedAt`.

### Limitations

The actor extracts public result-page data.

It does not log into Marktplaats.

It does not scrape private messages, account pages, or non-public seller data.

Listing details can vary by category because Marktplaats exposes different attributes for different verticals.

If a listing disappears between runs, it will no longer be returned by Marktplaats result pages.

### Troubleshooting

#### Why did I get fewer listings than `maxItems`?

The category or search may have fewer public results than requested, or `maxPagesPerUrl` may be too low.

Increase `maxPagesPerUrl` for deeper categories.

#### Why are some fields empty?

Marktplaats does not expose every field for every category.

For example, coordinates, seller verification, or extended attributes can be missing on some listings.

#### Why are attributes different between categories?

Attributes are category-specific.

Cars can include mileage and fuel, while furniture or electronics categories use different specs.

### Data quality notes

The actor deduplicates by `listingId` within each run.

Image URLs are normalized to full HTTPS URLs.

Prices are converted from cents to euros where raw cents are available.

The raw cents value is also preserved as `priceCents`.

### Legality and responsible use

This actor collects publicly available Marktplaats result-page data.

Use it responsibly and comply with applicable laws, Marktplaats terms, and privacy requirements.

Do not use scraped data for spam, fraud, harassment, or discriminatory profiling.

### Related scrapers

Explore other automation-lab actors for marketplace and commerce workflows:

- https://apify.com/automation-lab/olx-poland-classifieds-scraper
- https://apify.com/automation-lab/olx-bulgaria-classifieds-scraper
- https://apify.com/automation-lab/gumtree-uk-classifieds-scraper
- https://apify.com/automation-lab/finn-no-marketplace-scraper
- https://apify.com/automation-lab/tradera-scraper

### FAQ

#### Can I scrape multiple categories in one run?

Yes. Add multiple Marktplaats URLs to `startUrls`.

#### Can I use search result URLs?

Yes. Public Marktplaats search URLs are supported when they render listing data in the page.

#### Does the actor open each listing detail page?

No. The MVP extracts result-page listing data to keep runs fast and affordable.

#### Can I export to CSV or Excel?

Yes. Apify datasets support CSV, Excel, JSON, XML, RSS, and HTML exports.

#### Can I monitor new listings?

Yes. Schedule the actor and compare `listingId` values between datasets.

#### Does it need a proxy?

The current implementation uses direct HTTP requests. If Marktplaats starts blocking direct traffic, proxy support can be added later.

### Changelog

- Initial version: public Marktplaats category/search listing extraction with pagination, prices, sellers, images, attributes, and PPE charging.

# Actor input Schema

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

Marktplaats.nl result pages to scrape. Use category URLs such as /l/auto-s/ or search URLs such as /q/fiets/.

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

Maximum number of listings to save across all start URLs. Keep this low for first tests.

## `maxPagesPerUrl` (type: `integer`):

Safety cap for pagination from each start URL.

## `includeAttributes` (type: `boolean`):

Save Marktplaats attributes such as mileage, fuel, size, condition, model, or other category-specific facts when available.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.marktplaats.nl/l/auto-s/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 3,
  "includeAttributes": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.marktplaats.nl/l/auto-s/"
        }
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 3,
    "includeAttributes": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/marktplaats-netherlands-classifieds-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": [{ "url": "https://www.marktplaats.nl/l/auto-s/" }],
    "maxItems": 20,
    "maxPagesPerUrl": 3,
    "includeAttributes": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/marktplaats-netherlands-classifieds-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": [
    {
      "url": "https://www.marktplaats.nl/l/auto-s/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 3,
  "includeAttributes": true
}' |
apify call automation-lab/marktplaats-netherlands-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Marktplaats Netherlands Classifieds Scraper",
        "description": "Extract public Marktplaats.nl listings with prices, sellers, locations, attributes, images, and URLs for Dutch marketplace monitoring.",
        "version": "0.1",
        "x-build-id": "m6GbdNk3dJVdUZFk5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~marktplaats-netherlands-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-marktplaats-netherlands-classifieds-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~marktplaats-netherlands-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-marktplaats-netherlands-classifieds-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~marktplaats-netherlands-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-marktplaats-netherlands-classifieds-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Search or category URLs",
                        "type": "array",
                        "description": "Marktplaats.nl result pages to scrape. Use category URLs such as /l/auto-s/ or search URLs such as /q/fiets/.",
                        "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 listings to save across all start URLs. Keep this low for first tests.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum result pages per URL",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap for pagination from each start URL.",
                        "default": 3
                    },
                    "includeAttributes": {
                        "title": "Include listing attributes",
                        "type": "boolean",
                        "description": "Save Marktplaats attributes such as mileage, fuel, size, condition, model, or other category-specific facts when available.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```