# Autotrack Automotive Search Scraper (`stealth_mode/autotrack-automotive-search-scraper`) Actor

Scrape vehicle inventory from Autotrack.nl with complete specifications, pricing, images, and seller details. This automotive scraper collects 17 essential fields per listing — perfect for dealerships, price aggregators, market researchers, and automotive platforms.

- **URL**: https://apify.com/stealth\_mode/autotrack-automotive-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
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

## Autotrack Automotive Scraper: Extract Vehicle Listings Effortlessly

---

### What Is Autotrack.nl?

Autotrack.nl is the Netherlands' leading online automotive marketplace, featuring thousands of vehicle listings from private sellers and dealerships. The platform includes detailed vehicle specifications, pricing, photos, VR images, and availability status. Manually extracting this data from search results is inefficient — the **Autotrack Automotive Scraper** automates bulk data collection, transforming vehicle listings into clean, structured datasets ready for analysis or integration.

---

### Overview

The **Autotrack Automotive Scraper** extracts comprehensive vehicle information from Autotrack.nl search result pages, capturing essential listing details in a structured format. It is designed for:

- **Dealership networks** aggregating inventory across multiple locations
- **Price comparison platforms** building automotive datasets
- **Market analysts** tracking vehicle pricing and availability trends
- **Automotive researchers** studying vehicle availability and seller behavior
- **Inventory management systems** syncing external listings

Key strengths include efficient batch extraction, VR image tracking, flexible pagination support, and robust error handling via `ignore_url_failures`.

---

### Input Format

The scraper accepts a JSON configuration object with three main parameters:

```json
{
  "urls": [
    "https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Parameter Details

| Parameter | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | List of Autotrack search result page URLs to scrape | `["https://www.autotrack.nl/aanbod?pageNumber=2..."]` |
| `ignore_url_failures` | Boolean | If `true`, scraper continues running even if some URLs fail | `true` / `false` |
| `max_items_per_url` | Integer | Maximum number of vehicle listings to extract per URL | `200`, `50`, `1000` |

#### URL Structure & Pagination

Autotrack.nl search URLs support the following query parameters:

- **pageNumber** — Current page number (e.g., `pageNumber=2` for page 2)
- **pageSize** — Number of results per page (e.g., `pageSize=30`)
- **sortField** — Sort order field (e.g., `relevance`, `price`, `date`)
- **sortOrder** — Sort direction: `asc` (ascending) or `desc` (descending)

> **Tip:** To scrape multiple pages, add separate URLs with incrementing `pageNumber` values (e.g., page 1, 2, 3…) to the `urls` array.

***

### Output Format

**Sample output**

```json
{
  "beschikbaarheids_status": "beschikbaar",
  "aantal_vr_fotos": 0,
  "datum_geplaatst": "2026-06-12T08:10:44.111Z",
  "aanbieder": {
    "chat_enabled": false,
    "aanbiedergegevens": {
      "website": "https://www.henkscholten.nl/",
      "plaatsnaam_slug": "naarden",
      "provincie_slug": "noord-holland",
      "plaatsnaam": "Naarden",
      "telefoonnummer": "035-2032112",
      "naam": "Henk Scholten Naarden",
      "provincie": "Noord-Holland"
    },
    "whatsapp_enabled": false,
    "emailadres": "support@henkscholten.nl",
    "soort": "MERKDEALER_GEKOZEN_MERK",
    "aanbieder_id": 17761,
    "soort_slug": "merkdealer-gekozen-merk",
    "proefrit_aan_huis_enabled": true
  },
  "autogegevens": {
    "algemeen": {
      "model_slug": "v40-cross-country",
      "merk_slug": "volvo",
      "carrosserievorm_slug": "hatchback",
      "carrosserievorm": "HATCHBACK",
      "brandstofsoort": "BENZINE",
      "commerciele_uitvoering": "T3 Automaat Edition+ | Afneembare trekhaak | Stoelverwarming | Navigatie | Volvo on Call | Climate control | Parkeersensoren achter | High performance audio | Dealeronderhouden",
      "voertuigsoort": "PERSONENAUTO",
      "merk_id": "24f2f778-840d-4537-a9d8-119db104ca2e",
      "kleur_slug": "wit",
      "brandstofsoort_slug": "benzine",
      "transmissietype": "AUTOMATISCH",
      "modelnaam": "V40 Cross Country",
      "kleur": "WIT",
      "aantal_deuren": 5,
      "voertuigsoort_slug": "personenauto",
      "model_id": "862ae3cb-8520-403d-a5f1-5067b0e3fde4",
      "merknaam": "Volvo",
      "transmissietype_slug": "automatisch",
      "uitvoering": "T3 Automaat Edition+ | Afneembare trekhaak | Stoelverwarming | Navigatie | Volvo on Call | Climate control | Parkeersensoren achter | High performance audio | Dealeronderhouden"
    },
    "garanties": {
      "fabrieksgarantietermijn_algemeen": 12
    },
    "milieu": {
      "energielabel_slug": "d",
      "energielabel": "D"
    },
    "maten_en_gewichten": {
      "minimale_wegenbelasting": 226,
      "maximale_wegenbelasting": 247
    },
    "motor": {
      "vermogen_pk": 153,
      "vermogen_kw": 112,
      "motorinhoud": 1498
    },
    "geschiedenis": {
      "kilometerstand_correct": true,
      "kilometerstand": 123386,
      "datum_eerste_toelating_internationaal": "2018-11-08T00:00:00.000Z",
      "catalogusprijs": 32515,
      "geimporteerd": false,
      "btw_verrekenbaar": true,
      "bouwjaar": 2018
    }
  },
  "aantal_fotos": 22,
  "honderdprocentonderhouden": true,
  "soort_auto_slug": "occasion",
  "advertentie_id": 59494786,
  "prijs": {
    "bedrag_inclusief_btw": 18500,
    "bedrag": 18500,
    "inclusief_btw": true,
    "totaal": 18500,
    "totaal_exclusief_btw": 15590,
    "bedrag_exclusief_btw": 15590,
    "totaal_inclusief_btw": 18500
  },
  "kenteken": "TX381J",
  "beschikbaarheids_status_slug": "beschikbaar",
  "soort_auto": "OCCASION",
  "reports": {
    "autoweek": "https://www.autoweek.nl/report/a793c3e6-0494-41c6-af27-c1185617e7ff.pdf",
    "rdw": "https://voertuigrapportdownloaden.rdw.nl/kenteken/TX381J"
  },
  "media": {
    "video_urls": [
      "https://autotrack.movieplayer.nl/tg/9099090/"
    ],
    "vr_photo_urls": [],
    "photos": [
      "59494786/0-a408d6142e8751a3bee138411e19b303.jpg",
      "59494786/0-c5d4d01825ca26ff8eade53b0c44e10b.jpg",
      "59494786/0-5bbae47ca4b8f970a7a7485d399fc6b2.jpg",
      "59494786/0-8fbe9577fe625011502a5773c839ad96.jpg",
      "59494786/0-8fbccf26553decddddc87120747fdf13.jpg",
      "59494786/0-a335a87e699ae7b3cc2c8b4c0e334323.jpg",
      "59494786/0-c61a25403b3efef4dc25a365d4750928.jpg",
      "59494786/0-449e8ed6018aa42289abba86df530af6.jpg",
      "59494786/0-e59b315bae990c0c2104d851d396e3be.jpg",
      "59494786/0-ee5e5017409817525b39d6eed2df17de.jpg",
      "59494786/0-96ed6234d946b67d07791941488caa08.jpg",
      "59494786/0-6e88f3d680cd5657963d2c497a2b8c4d.jpg",
      "59494786/0-b190d56fe54c8e79f79d02bf83d90889.jpg",
      "59494786/0-2e937dc50716b8d8df29c2b128816377.jpg",
      "59494786/0-7bedc6a474963ec2d794f6bc6a079866.jpg",
      "59494786/0-f2e49d69771d90daaf6bf3d371af57b1.jpg",
      "59494786/0-9d2ba6e7e37d42bfde8632b476ff2ecb.jpg",
      "59494786/0-8656d514253186d01af6ca73e511ef7b.jpg",
      "59494786/0-80d43c5fbc8290f557baf08f5ab5d59e.jpg",
      "59494786/0-80752da17a14d197e9d2b3898cb9ca84.jpg",
      "59494786/0-55d51d945b7fc630de16a59124a7ac9d.jpg",
      "59494786/0-41298ccd617b62636369fdbf7d231e63.jpg"
    ]
  },
  "url": "https://www.autotrack.nl/a/volvo-v40-cross-country-benzine-2018-59494786",
  "aantal_videos": 1,
  "from_url": "https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"
}
```

Each vehicle listing returns a rich record with 17 fields covering vehicle specs, pricing, images, and seller information:

#### Vehicle Specifications

| Field | Meaning |
|---|---|
| `Autogegevens` | Core vehicle data including make, model, year, mileage, fuel type, transmission |
| `Soort Auto` | Vehicle type (e.g., sedan, SUV, hatchback, estate) |
| `Soort Auto Slug` | URL-friendly vehicle type identifier |
| `Kenteken` | License plate number (Dutch registration) |
| `Prijs` | Listed price in EUR |

#### Listing & Availability

| Field | Meaning |
|---|---|
| `Advertentie ID` | Unique identifier for the vehicle listing |
| `URL` | Direct link to the complete vehicle listing on Autotrack |
| `Datum Geplaatst` | Date the vehicle was listed (publication timestamp) |
| `Beschikbaarheids Status` | Current availability status (e.g., available, sold, reserved) |
| `Beschikbaarheids Status Slug` | Machine-readable status code |

#### Media & Documentation

| Field | Meaning |
|---|---|
| `Aantal Fotos` | Total number of standard photos included |
| `Aantal VR Fotos` | Count of 360° VR photos (immersive image technology) |
| `Aantal Videos` | Number of video files attached to the listing |
| `Media` | Collection of photo/video URLs and metadata |

#### Seller & Reports

| Field | Meaning |
|---|---|
| `Aanbieder` | Seller/dealer information including name, location, contact details |
| `Honderdprocentonderhouden` | Service history indicator (full maintenance records) |
| `Reports` | Inspection reports, vehicle history checks, or damage reports if available |

***

### How to Use

1. **Gather Autotrack URLs** — Visit Autotrack.nl and apply filters (brand, price range, location, mileage). Copy the resulting search URL.
2. **Prepare your configuration** — Paste the search URL(s) into the `urls` array. For multiple pages, add separate URLs with different `pageNumber` values.
3. **Set extraction limits** — Define `max_items_per_url` (e.g., 200 for bulk exports, 50 for testing).
4. **Enable error tolerance** — Set `ignore_url_failures: true` to skip temporarily unavailable URLs without halting the run.
5. **Execute the scraper** — Start the actor and monitor progress in the run log.
6. **Export results** — Download extracted data as JSON, CSV, or Excel for analysis or system integration.

**Best practices:**

- Use realistic `pageSize` values; Autotrack typically defaults to 15–30 items per page
- Test with a single URL and lower `max_items_per_url` before running large batches
- Export data regularly during long runs to avoid timeout issues

***

### Use Cases & Business Value

- **Inventory aggregation:** Combine Autotrack listings with internal stock to create unified catalogs
- **Competitive pricing analysis:** Monitor competitor pricing, discounts, and availability patterns
- **Lead generation:** Identify vehicles matching specific criteria for targeted marketing campaigns
- **Market intelligence:** Analyze vehicle supply, demand, and pricing trends by region, brand, or model
- **API integration:** Feed structured data into CRM systems, inventory management platforms, or data warehouses

The Autotrack Automotive Scraper eliminates hours of manual data entry, delivering consistent, machine-readable vehicle data at scale — enabling faster decision-making and more effective business operations.

***

### Conclusion

The **Autotrack Automotive Scraper** is an essential tool for automotive businesses, platforms, and researchers needing reliable vehicle data from the Netherlands' largest marketplace. With 17 data fields per listing and flexible configuration, it streamlines inventory management, competitive analysis, and market research. Start scraping today and transform raw listings into actionable intelligence.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Motos list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/autotrack-automotive-search-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 = {
    "urls": ["https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/autotrack-automotive-search-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 '{
  "urls": [
    "https://www.autotrack.nl/aanbod?pageNumber=2&pageSize=30&sortField=relevance&sortOrder=asc"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/autotrack-automotive-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Autotrack Automotive Search Scraper",
        "description": "Scrape vehicle inventory from Autotrack.nl with complete specifications, pricing, images, and seller details. This automotive scraper collects 17 essential fields per listing — perfect for dealerships, price aggregators, market researchers, and automotive platforms.",
        "version": "0.0",
        "x-build-id": "pZAhGGdyrRuf59DNy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~autotrack-automotive-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-autotrack-automotive-search-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/stealth_mode~autotrack-automotive-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-autotrack-automotive-search-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/stealth_mode~autotrack-automotive-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-autotrack-automotive-search-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": {
                    "urls": {
                        "title": "URLs of the Motos list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Motos list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
