# 2dehands Scraper (`ivanvs/2dehands-scraper`) Actor

Extract data from 2dehands.be across thousands of listings — real estate, cars, jobs, and more. Scrape titles, descriptions, images, prices, location, seller names, and contact details, plus every other ad field. Unlimited and extremely fast!

- **URL**: https://apify.com/ivanvs/2dehands-scraper.md
- **Developed by:** [Gen First](https://apify.com/ivanvs) (community)
- **Categories:** Real estate, E-commerce, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 listings

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

## 2dehands Scraper

Extract listings, prices, photos, seller info, and location data from
[2dehands.be](https://www.2dehands.be/) — no login, no cookies, and no proxy setup
required. 2dehands Scraper turns any 2dehands search, category, single-ad, or seller
profile URL into clean, structured JSON you can export to CSV, Excel, JSON, XML, or
HTML Table.

### What does 2dehands Scraper do?

- 🔎 **Scrapes search & category pages** — paste any 2dehands category or search-results URL and collect every listing on it (with automatic pagination).
- 📄 **Scrapes individual ads** — paste a single ad URL to get its full detail record.
- 👤 **Scrapes seller profiles** — paste a seller/store profile URL to collect every active listing that seller has published (private sellers and professional shops alike).
- 🚗 **Works across all categories** — cars and vehicles, electronics, home & garden, fashion, hobbies, services, and more.
- 🧾 **Returns rich structured data** — title, description, price, currency, images, location, seller profile, promotion traits, and category-specific attributes (e.g. mileage, fuel, transmission, and options for cars).
- 🔓 **No login or session cookies** required.
- 🌐 **Proxy preconfigured** — uses Apify residential proxy (country `BE`) for reliable performance out of the box.
- 📤 **Export anywhere** — JSON, CSV, Excel, XML, or HTML Table.

### About 2dehands

2dehands.be ("second-hand" in Dutch) is one of Belgium's largest online classifieds
marketplaces and the Belgian sister site of Marktplaats. It hosts a broad range of
listings across vehicles, electronics, home & garden, fashion, and services, making it
a valuable source of Belgian marketplace and pricing data.

### What can you do with this data?

- **Price monitoring** — track asking prices for cars, electronics, and other goods over time.
- **Vehicle & product price comparison** — benchmark prices across many comparable listings.
- **Seller & inventory tracking** — drop a seller's profile URL to monitor a specific shop's or private seller's full inventory.
- **Dataset building** — feed structured listing data into analytics, dashboards, or ML pipelines.

### How to use 2dehands Scraper

1. Open the actor on Apify.
2. Add one or more 2dehands URLs to the **urls** field (search/category pages, single ads, or seller profiles).
3. Set **maxRecords** to cap how many listings to collect (default `100`).
4. Click **Start** and let the scraper run.
5. Download the results in JSON, CSV, Excel, XML, or HTML Table.

#### Input parameters

| Input parameter | Description                                                          | Required | Default value                                                                                                           |
| --------------- | -------------------------------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------- |
| `urls`          | 2dehands URLs to scrape (search/category, single-ad, or seller URLs) | `true`   | `{ "url": "https://www.2dehands.be/l/auto-s/fiat/f/doblo/771/p/2/#Language:all-languages\|constructionYearFrom:2017" }` |
| `maxRecords`    | Maximum number of records to scrape                                  | `false`  | `100`                                                                                                                   |

#### Supported input URLs

2dehands Scraper accepts three kinds of URLs:

- **Search / category URL** — collects every listing on the page (and paginates):
  - `https://www.2dehands.be/l/auto-s/q/bmw+x5/`
  - Category, keyword, attribute filters, and hash-based ranges (e.g. `#constructionYearFrom:2017`) are all supported.
- **Single ad URL** — collects one listing's full detail record:
  - `https://www.2dehands.be/v/auto-s/bmw/m2411592782-bmw-gt-630i-2018`
  - Pattern: `https://www.2dehands.be/v/<category>/<brand>/<id>-<slug>`.
- **Seller profile URL** — collects every active listing from one seller (and paginates):
  - `https://www.2dehands.be/u/spardex/28393822/`
  - Pattern: `https://www.2dehands.be/u/<slug>/<sellerId>/`. Both private sellers and professional shops use this form. Results respect `maxRecords`.

You can mix all three URL types in the same `urls` list. Each output record's `inputUrl`
field is set to the original URL you supplied that produced it.

### Examples

#### Input

Scrape 20 search results from a given search URL:

```json
{
  "urls": ["https://www.2dehands.be/l/auto-s/q/bmw+x5/"],
  "maxRecords": 20
}
````

Scrape up to 20 listings from a single seller's profile:

```json
{
  "urls": ["https://www.2dehands.be/u/spardex/28393822/"],
  "maxRecords": 20
}
```

#### Output

> Seller-profile runs return the **same ad records** as search and single-ad runs — one
> record per listing — with each record's `inputUrl` set to the URL you supplied.

> The example below is illustrative — personal and identifying values have been anonymized.

```json
{
  "id": "m2411592782",
  "url": "https://www.2dehands.be/v/auto-s/bmw/m2411592782-bmw-gt-630i-2018",
  "title": "BMW GT 630i 2018",
  "description": "BMW 630i Gran Turismo (G32) – Essence – Euro 6d-TEMP – Excellent état\n\nCaractéristiques :\n• BMW 630i GT\n• Moteur essence 2.0 Turbo – 258 ch (190 kW)\n• Norme Euro 6d-TEMP\n• Boîte automatique\n• 5 portes / 5 places\n• Intérieur cuir noir\n• Climatisation automatique bi-zone\n• Navigation GPS BMW Professional\n• Capteurs de stationnement\n• Jantes alliage BMW\n\nVéhicule en très bon état général, idéal pour les longs trajets. Essai possible pour acheteur sérieux.",
  "categoryId": "96",
  "categoryName": "BMW",
  "parentCategoryId": "91",
  "parentCategoryName": "Auto's",
  "adType": "RegularPaid",
  "brand": "BMW",
  "price": 19000,
  "priceCents": 1900000,
  "priceType": "MIN_BID",
  "currency": "EUR",
  "images": [
    "https://images.2dehands.com/api/v1/hz-twh-pro-listing/images/3e1c1f3c-fea1-4d55-a564-7b1810a4678e?rule=ecg_mp_eps$_85.jpg",
    "https://images.2dehands.com/api/v1/hz-twh-pro-listing/images/865ce191-6ec9-42ce-a57f-2349d08dda53?rule=ecg_mp_eps$_85.jpg",
    "https://images.2dehands.com/api/v1/hz-twh-pro-listing/images/ce5f07e0-52f4-493a-87a0-fb1e38cd1059?rule=ecg_mp_eps$_85.jpg"
  ],
  "thumbnailUrl": "https://images.2dehands.com/api/v1/hz-twh-pro-listing/images/3e1c1f3c-fea1-4d55-a564-7b1810a4678e?rule=ecg_mp_eps$_85.jpg",
  "imageCount": 9,
  "createdAt": "2026-06-17T12:57:44Z",
  "viewCount": 16,
  "favoritedCount": 1,
  "isReserved": false,
  "isCarAd": true,
  "traits": ["DAG_TOPPER_7DAYS", "PACKAGE_PREMIUM"],
  "highlights": [],
  "attributes": {
    "brand": "BMW 6 Reeks",
    "constructionYear": "2018",
    "mileage": "162.000 km",
    "fuel": "Benzine",
    "transmission": "Automaat",
    "cylinderCapacity": "2.0 liter",
    "euronormBE": "Euro 6",
    "vehicleType": "Berline",
    "color": "Zilver of Grijs",
    "upholstery": "Leder",
    "interiorColor": "Zwart",
    "powerWheelDriver": "Achterwiel",
    "serviceHistory": "Dealer onderhouden",
    "options": [
      "Achteruitrijcamera",
      "Airbags",
      "Airconditioning",
      "Apple Carplay",
      "Bluetooth",
      "Elektrische ramen",
      "Lederen bekleding",
      "Parkeercamera",
      "Start-stop-systeem",
      "USB"
    ]
  },
  "location": {
    "cityName": "Zaventem",
    "countryName": "Belgie",
    "countryAbbreviation": "BE",
    "postcode": null,
    "latitude": null,
    "longitude": null,
    "isAbroad": false
  },
  "seller": {
    "id": "00000000",
    "name": "example_seller",
    "type": "CONSUMER",
    "pageUrl": "https://www.2dehands.be/u/example_seller/00000000/",
    "phoneNumber": "",
    "websiteUrl": null,
    "websiteDisplayUrl": null,
    "activeYears": 9
  },
  "inputUrl": "https://www.2dehands.be/l/auto-s/q/bmw+x5/"
}
```

### Output fields

Each scraped listing is one dataset record (stored in the `ad_details` dataset) with the
following fields. Fields typed as optional may be `null` when 2dehands does not provide a
value.

#### Core

| Field                | Description                                                  |
| -------------------- | ------------------------------------------------------------ |
| `id`                 | Unique 2dehands listing ID (e.g. `m2411592782`).             |
| `url`                | Canonical URL of the ad.                                     |
| `title`              | Listing title.                                               |
| `description`        | Full listing description text (newlines preserved).          |
| `categoryId`         | 2dehands category ID.                                        |
| `categoryName`       | Human-readable category name.                                |
| `parentCategoryId`   | Parent (L1) category ID.                                     |
| `parentCategoryName` | Parent (L1) category name.                                   |
| `adType`             | Ad type (e.g. `RegularPaid`).                                |
| `brand`              | Listing brand, when available.                               |
| `images`             | Array of full-size image URLs.                               |
| `thumbnailUrl`       | URL of the thumbnail image.                                  |
| `imageCount`         | Number of images on the listing.                             |
| `createdAt`          | First publication date/time (ISO 8601).                      |
| `viewCount`          | Number of times the ad has been viewed.                      |
| `favoritedCount`     | Number of times the ad has been favorited.                   |
| `isReserved`         | Whether the item is marked as reserved.                      |
| `isCarAd`            | Whether the listing is a car/vehicle ad.                     |
| `traits`             | Promotion traits applied to the ad (e.g. `PACKAGE_PREMIUM`). |
| `highlights`         | Listing highlights, when present.                            |
| `inputUrl`           | The original URL you supplied that produced this record.     |

#### Pricing

| Field        | Description                                       |
| ------------ | ------------------------------------------------- |
| `price`      | Price as a number (in `currency`).                |
| `priceCents` | Price in cents (integer).                         |
| `priceType`  | Price type (e.g. `FIXED`, `MIN_BID`, `RESERVED`). |
| `currency`   | Currency code (e.g. `EUR`).                       |

#### Location (`location`)

| Field                    | Description                                  |
| ------------------------ | -------------------------------------------- |
| `cityName`               | City name.                                   |
| `countryName`            | Country name (e.g. `Belgie`).                |
| `countryAbbreviation`    | Country code (e.g. `BE`).                    |
| `postcode`               | Postal code, when available.                 |
| `latitude` / `longitude` | Geographic coordinates, when available.      |
| `isAbroad`               | Whether the item is located outside Belgium. |

#### Seller (`seller`)

| Field               | Description                                  |
| ------------------- | -------------------------------------------- |
| `id`                | Seller account ID.                           |
| `name`              | Seller / shop display name.                  |
| `type`              | Seller type (e.g. `CONSUMER`, professional). |
| `pageUrl`           | URL of the seller's profile page.            |
| `phoneNumber`       | Seller phone number, when published.         |
| `websiteUrl`        | Seller website URL, when published.          |
| `websiteDisplayUrl` | Display form of the seller website.          |
| `activeYears`       | How many years the seller has been active.   |

#### Attributes (`attributes`)

A flat, category-specific key→value map (`Record<string, string | string[]>`). Most values
are strings; some (such as a car's `options`) are arrays of strings. The exact keys depend
on the listing's category — for cars these include `constructionYear`, `mileage`, `fuel`,
`transmission`, `cylinderCapacity`, `color`, and `options`, among others.

### Output formats

Results are stored in an Apify dataset (`ad_details`). After a run finishes you can download
the data as **JSON, CSV, Excel, XML, or HTML Table**, or pull it via the Apify API. The
dataset's `overview` view surfaces `id`, `title`, `price`, `currency`, and `url`.

### ❓ FAQ

#### Do I need proxies to scrape 2dehands?

No. The actor is preconfigured to use Apify proxy for optimal
performance — you don't need to set anything up.

#### Do I need to write code?

No. 2dehands Scraper is a no-code tool: paste your URLs, set `maxRecords`, and run.

#### Can I scrape a single ad or a whole category?

Both. Provide a search/category URL to collect many listings, or a single ad URL to collect
one listing's full record. You can mix search, single-ad, and seller-profile URLs in the
same `urls` list.

#### Can I scrape every listing from one seller?

Yes. Paste the seller's profile URL — `https://www.2dehands.be/u/<slug>/<sellerId>/` — and
the scraper collects that seller's active listings, up to `maxRecords`. This works for both
private sellers and professional shops. Each result is a full ad record, identical to
single-ad output, with `inputUrl` set to the profile URL.

#### How many listings can I scrape?

Use `maxRecords` to set the cap (default `100`). Increase it to collect more results across
paginated search and seller pages.

#### What data can I extract?

Title, description, price, currency, images, location, seller profile, promotion traits, and
category-specific attributes (such as mileage, fuel, and transmission for cars). See
[Output fields](#output-fields).

#### Is it legal to scrape 2dehands?

Scraping publicly available data is generally permitted, but you are responsible for how you
use it. Avoid collecting or storing personal data beyond what your use case requires, and
comply with applicable laws (including the GDPR) and 2dehands' terms. Consult legal counsel
if you're unsure.

#### What export formats are available?

JSON, CSV, Excel, XML, and HTML Table — plus programmatic access via the Apify API.

### Support

For custom or simplified outputs, or to report a bug, contact the developer at
**support (at) getmediumdata.com** or open an issue.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum number of records to be scraped

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

List of URLs from 2dehands (https://www.2dehands.be/) that needs to be scraped

## Actor input object example

```json
{
  "maxRecords": 10,
  "urls": [
    {
      "url": "https://www.2dehands.be/l/auto-s/fiat/f/doblo/771/p/2/#Language:all-languages|constructionYearFrom:2017"
    }
  ]
}
```

# 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 = {
    "maxRecords": 10,
    "urls": [
        {
            "url": "https://www.2dehands.be/l/auto-s/fiat/f/doblo/771/p/2/#Language:all-languages|constructionYearFrom:2017"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ivanvs/2dehands-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 = {
    "maxRecords": 10,
    "urls": [{ "url": "https://www.2dehands.be/l/auto-s/fiat/f/doblo/771/p/2/#Language:all-languages|constructionYearFrom:2017" }],
}

# Run the Actor and wait for it to finish
run = client.actor("ivanvs/2dehands-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 '{
  "maxRecords": 10,
  "urls": [
    {
      "url": "https://www.2dehands.be/l/auto-s/fiat/f/doblo/771/p/2/#Language:all-languages|constructionYearFrom:2017"
    }
  ]
}' |
apify call ivanvs/2dehands-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "2dehands Scraper",
        "description": "Extract data from 2dehands.be across thousands of listings — real estate, cars, jobs, and more. Scrape titles, descriptions, images, prices, location, seller names, and contact details, plus every other ad field. Unlimited and extremely fast!",
        "version": "0.0",
        "x-build-id": "XSZwOrsrv5zbQxCwo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ivanvs~2dehands-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ivanvs-2dehands-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/ivanvs~2dehands-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ivanvs-2dehands-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/ivanvs~2dehands-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ivanvs-2dehands-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": [
                    "urls"
                ],
                "properties": {
                    "maxRecords": {
                        "title": "Maximum number of records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to be scraped",
                        "default": 100
                    },
                    "urls": {
                        "title": "List of URLs",
                        "type": "array",
                        "description": "List of URLs from 2dehands (https://www.2dehands.be/) that needs to be scraped",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
