# Drom.ru Car Marketplace Scraper (`automation-lab/drom-ru-car-marketplace-scraper`) Actor

Scrape Drom.ru vehicle listings for prices, mileage, specs, images, and locations. Export structured Russian car marketplace data.

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

## Pricing

from $0.60 / 1,000 vehicle listing extracteds

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

## Drom.ru Car Marketplace Scraper 🚗

Scrape public Drom.ru vehicle listings from `auto.drom.ru` and turn Russian car marketplace pages into structured data for pricing, inventory, and market intelligence workflows.

The actor extracts vehicle listing URLs, prices, make/model/year, mileage, engine, fuel, transmission, drivetrain, location, images, and posting time from Drom search result pages.

### What does Drom.ru Car Marketplace Scraper do?

It visits public Drom.ru car search pages.

It parses server-rendered listing cards.

It saves every vehicle as a structured dataset row.

It supports exact Drom start URLs.

It also supports generated URLs from region, make, model, year, and price filters.

It is designed for marketplace monitoring, car price analysis, export/import research, and inventory tracking.

### Who is it for?

Used-car dealers can monitor competing listings.

Exporters can find supply by model and location.

Importers can compare Russian-market prices.

Analysts can build pricing benchmarks.

Automotive marketplaces can watch inventory shifts.

Lead generation teams can identify public listing opportunities.

Researchers can collect historical snapshots from public search pages.

### Why use this actor?

Drom.ru is one of the largest automotive classified sites in Russia.

Manual browsing is slow when you need hundreds or thousands of listings.

The actor normalizes important fields into a clean table.

You can run it on a schedule to track price and stock movement.

You can export results to CSV, JSON, Excel, Google Sheets, or a database.

### Data you can extract

| Field | Description |
| --- | --- |
| `listingId` | Numeric Drom listing id when available |
| `url` | Public listing URL |
| `title` | Listing title shown by Drom |
| `make` | Parsed vehicle make |
| `model` | Parsed vehicle model |
| `year` | Parsed production year |
| `price` | Listing price in RUB |
| `currency` | Currency code, usually `RUB` |
| `mileageKm` | Mileage in kilometers |
| `engine` | Engine text from the listing card |
| `fuel` | Fuel type |
| `transmission` | Gearbox/transmission |
| `drivetrain` | Drivetrain text |
| `location` | City or region shown on Drom |
| `sellerName` | Reserved for public seller/dealer name when available |
| `description` | Compact listing specification snippet |
| `imageUrls` | Public image URLs from the listing card |
| `postedAtText` | Relative posting/update time shown by Drom |
| `sourceUrl` | Search page that produced the row |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Drom.ru car listings?

This actor uses pay-per-event pricing.

There is a small run-start charge.

Then you pay per vehicle listing extracted.

For typical marketplace research, start with 20 listings.

Increase `maxResults` after confirming the filter returns the inventory you need.

Apify platform costs and proxy costs depend on your run size and proxy configuration.

### Input options

Use `startUrls` when you already have Drom search URLs.

Use `region` to target a city or region slug.

Use `make` and `model` to target a vehicle line.

Use `minPrice` and `maxPrice` to focus on a price band.

Use `minYear` and `maxYear` to focus on production years.

Use `maxResults` to control dataset size.

Use `maxPages` to control pagination.

Use `proxyConfiguration` if Drom rate-limits your traffic.

### Example input

```json
{
  "startUrls": [
    { "url": "https://auto.drom.ru/toyota/corolla/?minyear=2015&maxprice=1500000" }
  ],
  "maxResults": 20,
  "maxPages": 2,
  "maxRequestRetries": 3
}
````

### Filter-based input example

```json
{
  "region": "vladivostok",
  "make": "toyota",
  "model": "prius",
  "minYear": 2016,
  "maxPrice": 2500000,
  "maxResults": 100
}
```

### Output example

```json
{
  "listingId": "143713800",
  "url": "https://auto.drom.ru/tyumen/toyota/corolla/143713800.html",
  "title": "Toyota Corolla, 2019",
  "make": "Toyota",
  "model": "Corolla",
  "year": 2019,
  "price": 485000,
  "currency": "RUB",
  "mileageKm": 150000,
  "engine": "1.8 л (140 л.с.)",
  "fuel": "бензин",
  "transmission": "вариатор",
  "drivetrain": "передний",
  "location": "Тюмень",
  "description": "1.8 л (140 л.с.), бензин, вариатор, передний, 150 000 км",
  "imageUrls": ["https://s12.auto.drom.ru/photo/example/gen272wb.jpg"],
  "postedAtText": "52 минуты назад",
  "sourceUrl": "https://auto.drom.ru/toyota/corolla/",
  "scrapedAt": "2026-05-16T08:00:00.000Z"
}
```

### How to scrape Drom.ru car listings

Open the actor on Apify.

Paste one or more Drom search URLs.

Or fill in make, model, region, price, and year filters.

Set `maxResults` to a small value for the first run.

Run the actor.

Open the dataset preview.

Export the data in your preferred format.

Schedule the actor if you need recurring monitoring.

### Tips for better results

Use Drom's own filters in your browser first.

Copy the resulting URL into `startUrls`.

Keep `maxPages` aligned with `maxResults`.

Use proxy settings only when needed.

Avoid overly broad runs if you only need one make/model.

Run daily snapshots for price-trend use cases.

Deduplicate by `listingId` or `url` in downstream systems.

### Proxy and anti-bot notes

Drom can rate-limit repeated direct requests.

Small runs may work without a proxy.

If you see empty output or rate-limit messages, enable Apify Proxy.

The actor was built with HTTP parsing rather than a browser to keep compute cost low.

Conservative retries and pagination reduce unnecessary requests.

### Integrations

Send results to Google Sheets for inventory watchlists.

Export CSV files for pricing analysts.

Push JSON to a warehouse for historical market tracking.

Use Apify webhooks to notify a CRM when matching vehicles appear.

Connect scheduled runs to Make or Zapier for no-code workflows.

Use dataset API calls from Python or Node.js for internal dashboards.

### 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/drom-ru-car-marketplace-scraper').call({
  startUrls: [{ url: 'https://auto.drom.ru/toyota/corolla/' }],
  maxResults: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/drom-ru-car-marketplace-scraper").call(run_input={
    "startUrls": [{"url": "https://auto.drom.ru/toyota/corolla/"}],
    "maxResults": 50,
})
print(run["defaultDatasetId"])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~drom-ru-car-marketplace-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://auto.drom.ru/toyota/corolla/"}],"maxResults":50}'
```

### MCP for Claude Code and Claude Desktop

You can use this actor through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/drom-ru-car-marketplace-scraper
```

Claude Code setup:

```bash
claude mcp add apify-drom --url "https://mcp.apify.com/?tools=automation-lab/drom-ru-car-marketplace-scraper"
```

Claude Desktop JSON setup:

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

Example prompts:

```text
Scrape 50 Toyota Corolla listings from Drom and summarize median price by year.
```

```text
Run the Drom scraper for Vladivostok Prius listings and export the dataset URL.
```

### Scheduling workflows

Run hourly for very active models.

Run daily for market price monitoring.

Run weekly for broader regional inventory reports.

Store each run's dataset id so you can compare snapshots over time.

### Data quality notes

The actor extracts fields visible on search result cards.

Some listings may omit mileage or images.

Relative dates are kept as displayed by Drom.

Seller details may require future detail-page enrichment.

Prices are parsed as numbers where possible.

### Troubleshooting

If the run returns zero items, first check that the Drom URL shows listings in your browser.

If the page has listings but the actor returns none, enable Apify Proxy in the input.

If you request many items and get fewer, the search may not contain enough listings.

If Drom changes its page layout, contact support with the failing run URL.

### Legality

This actor extracts publicly available marketplace listing data.

Use the data responsibly.

Respect Drom.ru terms, robots policies, privacy laws, and applicable marketplace rules.

Do not scrape personal data you are not allowed to process.

### Related scrapers

Explore other Automation Lab actors at `https://apify.com/automation-lab/`.

Useful related categories include marketplace scrapers, real estate scrapers, ecommerce scrapers, and lead generation actors.

### FAQ

#### Can it scrape detail pages?

The MVP focuses on search result pages for reliability and cost control.

Detail-page enrichment can be added later if needed.

#### Can I scrape by exact Drom URL?

Yes. Put Drom search URLs into `startUrls`.

#### Can I scrape all Russia?

Yes. Leave `region` empty or use a broad Drom search URL.

#### Does it support Russian text?

Yes. The actor handles Drom pages encoded in Windows-1251 and outputs UTF-8 JSON.

#### Why are some fields null?

Drom listing cards do not always show every attribute for every vehicle.

#### What should I use as a unique key?

Use `listingId` when present, otherwise use `url`.

# Actor input Schema

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

One or more Drom.ru search/listing pages to scrape. Leave empty to build a URL from the filters below.

## `region` (type: `string`):

Optional Drom region path segment, for example moscow, krasnodar, vladivostok. Leave empty for all Russia.

## `make` (type: `string`):

Optional vehicle make slug, for example toyota, nissan, honda, lada.

## `model` (type: `string`):

Optional vehicle model slug, for example corolla, camry, prius.

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

Minimum listing price in Russian rubles.

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

Maximum listing price in Russian rubles.

## `minYear` (type: `integer`):

Minimum vehicle production year.

## `maxYear` (type: `integer`):

Maximum vehicle production year.

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

Maximum number of vehicle listings to save.

## `maxPages` (type: `integer`):

Maximum search-result pages to visit per start URL.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Drom usually works without a proxy for small runs; enable Apify Proxy if your run is rate-limited.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed Drom page requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://auto.drom.ru/toyota/corolla/?minyear=2015&maxprice=1500000"
    }
  ],
  "make": "toyota",
  "model": "corolla",
  "minYear": 2015,
  "maxResults": 20,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3
}
```

# 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://auto.drom.ru/toyota/corolla/?minyear=2015&maxprice=1500000"
        }
    ],
    "region": "",
    "make": "toyota",
    "model": "corolla",
    "minPrice": 0,
    "maxPrice": 0,
    "minYear": 2015,
    "maxResults": 20,
    "maxPages": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "maxRequestRetries": 3
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://auto.drom.ru/toyota/corolla/?minyear=2015&maxprice=1500000" }],
    "region": "",
    "make": "toyota",
    "model": "corolla",
    "minPrice": 0,
    "maxPrice": 0,
    "minYear": 2015,
    "maxResults": 20,
    "maxPages": 2,
    "proxyConfiguration": { "useApifyProxy": False },
    "maxRequestRetries": 3,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://auto.drom.ru/toyota/corolla/?minyear=2015&maxprice=1500000"
    }
  ],
  "region": "",
  "make": "toyota",
  "model": "corolla",
  "minPrice": 0,
  "maxPrice": 0,
  "minYear": 2015,
  "maxResults": 20,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3
}' |
apify call automation-lab/drom-ru-car-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drom.ru Car Marketplace Scraper",
        "description": "Scrape Drom.ru vehicle listings for prices, mileage, specs, images, and locations. Export structured Russian car marketplace data.",
        "version": "0.1",
        "x-build-id": "eRtVtGLtRbau7uBBq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~drom-ru-car-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-drom-ru-car-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~drom-ru-car-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-drom-ru-car-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~drom-ru-car-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-drom-ru-car-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Drom listing/search URLs",
                        "type": "array",
                        "description": "One or more Drom.ru search/listing pages to scrape. Leave empty to build a URL from the filters below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "region": {
                        "title": "Region slug",
                        "type": "string",
                        "description": "Optional Drom region path segment, for example moscow, krasnodar, vladivostok. Leave empty for all Russia."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Optional vehicle make slug, for example toyota, nissan, honda, lada."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Optional vehicle model slug, for example corolla, camry, prius."
                    },
                    "minPrice": {
                        "title": "Minimum price, RUB",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price in Russian rubles."
                    },
                    "maxPrice": {
                        "title": "Maximum price, RUB",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price in Russian rubles."
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Minimum vehicle production year."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Maximum vehicle production year."
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to save.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum search-result pages to visit per start URL.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Drom usually works without a proxy for small runs; enable Apify Proxy if your run is rate-limited."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed Drom page requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
