# Avito RU $1💰 URL | Keyword Filters | Enriched Output (`abotapi/avito-ru-scraper`) Actor

From $1/1k. Pull structured listing data from avito.ru by region, category, or direct URL. Supports filters and auto-pagination. Returns 25+ fields per listing, including price, full address, metro details, images, posting date, seller type, and verification badges.

- **URL**: https://apify.com/abotapi/avito-ru-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Real estate, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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

## Avito.ru Scraper

Pull structured listing data from avito.ru, the largest classifieds portal in Russia, in seconds. Search by region and category with filter inputs, or paste any avito.ru URL and the scraper walks pagination forward. Returns 25+ fields per listing including price, full address, metro station and walking distance, photo gallery URLs, posting date, seller type and verification badges.

### Why this scraper

- 25+ fields per listing (most competitors expose 10-12)
- Supports both modes: build a search from filters, or paste URLs verbatim
- All categories covered: apartments, houses, cars, motorcycles, jobs, services, electronics, home, hobbies, animals, and more
- All regions: moskva, sankt-peterburg, novosibirsk, rossiya (all of Russia), 80+ regional slugs
- Forward-paging from any URL (start at page 5, walk to page 20)
- Optional detail-page enrichment for full descriptions, photo galleries, seller stats, item attributes
- HTTP-only architecture, ~50 listings/second on Apify Residential proxy
- Around $1.50 per 1000 listings on the cheapest plan

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| id | `0000000000` |
| url | `https://www.avito.ru/moskva/kvartiry/listing-title-slug_0000000000` |
| title | `Sample listing title in Russian` |
| price | `12345678` |
| currency | `RUB` |
| priceText | `12 345 678 ₽` |
| category | `kvartiry` |
| subcategory | `prodam` |
| region | `moskva` |
| city | `moskva` |
| address | `ул. Примерная, 4, Образцовая, 6-10 мин.` |
| street | `ул. Примерная` |
| metro | `Образцовая` |
| metroId | `0` |
| metroDistanceMin | `10` |
| postedDate | `1 января` |
| description | `Full seller description text appears here when fetchDetails=true.` |
| photoUrls | `["https://90.img.avito.st/image/1/1.example", "..."]` |
| photoCount | `5` |
| badges | `["Sample badge text"]` |
| isVerified | `true` |
| sellerName | `Agent Name` |
| sellerType | `agency` |
| sellerRating | `0.0` |
| sellerReviewsCount | `0` |
| sellerSince | `На Авито с YYYY года` |
| viewsCount | `0` |
| attributes | `{"Sample attribute key": "Sample value"}` |

### How to use

#### Search by filters (recommended)

```json
{
  "mode": "search",
  "regions": ["moskva"],
  "category": "kvartiry",
  "dealType": "prodam",
  "minPrice": 1000000,
  "maxPrice": 9000000,
  "sortBy": "price_asc",
  "maxPages": 5,
  "maxListings": 250,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Cars in all of Russia, free-text search

```json
{
  "mode": "search",
  "regions": ["rossiya"],
  "category": "avtomobili",
  "query": "tesla model 3",
  "sortBy": "date_desc",
  "maxPages": 3,
  "maxListings": 150,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

#### Multi-region rentals with private sellers only

```json
{
  "mode": "search",
  "regions": ["moskva", "sankt-peterburg"],
  "category": "kvartiry",
  "dealType": "snyat",
  "ownerOnly": true,
  "maxPrice": 80000,
  "maxPages": 5,
  "maxListings": 200,
  "fetchDetails": true,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

#### Direct URLs (multi)

```json
{
  "mode": "url",
  "urls": [
    "https://www.avito.ru/moskva/kvartiry/prodam?p=2",
    "https://www.avito.ru/sankt-peterburg/avtomobili?q=BMW"
  ],
  "maxPages": 3,
  "maxListings": 200,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | Either `search` (use filters) or `url` (use direct URLs) |
| `regions` | string\[] | `["moskva"]` | Region slugs. Use `rossiya` for all of Russia |
| `category` | string | `kvartiry` | Top-level category slug (apartments, cars, jobs, services, etc.) |
| `dealType` | string | `prodam` | `prodam` (sale), `snyat` (rent), `kupit` (wanted), `sdam` (lease). Property categories only |
| `query` | string | empty | Free-text query, matches title and description |
| `minPrice` | int | empty | Minimum price in rubles |
| `maxPrice` | int | empty | Maximum price in rubles |
| `sortBy` | string | `default` | `default`, `date_desc`, `price_asc`, `price_desc` |
| `ownerOnly` | bool | false | Restrict to private (non-pro) sellers |
| `urls` | string\[] | empty | Direct avito URLs. URL mode only |
| `maxPages` | int | 5 | Pages to walk per region/URL (about 50 listings/page) |
| `maxListings` | int | 100 | Total cap across all searches. 0 = unlimited |
| `fetchDetails` | bool | false | Visit each listing for full description, all photos, seller stats |
| `proxy` | object | Apify Residential | Proxy configuration |

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "id": "0000000000",
  "url": "https://www.avito.ru/moskva/kvartiry/listing-title-slug_0000000000",
  "title": "Sample listing title in Russian",
  "price": 12345678,
  "currency": "RUB",
  "priceText": "12 345 678 ₽",
  "category": "kvartiry",
  "subcategory": "prodam",
  "region": "moskva",
  "city": "moskva",
  "address": "ул. Примерная, 4, Образцовая, 6-10 мин.",
  "street": "ул. Примерная",
  "metro": "Образцовая",
  "metroId": 0,
  "metroDistanceMin": 10,
  "postedDate": "1 января",
  "description": "Full seller description text appears here when fetchDetails=true.",
  "photoUrls": [
    "https://90.img.avito.st/image/1/1.example",
    "https://70.img.avito.st/image/1/1.example"
  ],
  "photoCount": 2,
  "badges": ["Sample badge text"],
  "isVerified": true,
  "sellerName": "Agent Name",
  "sellerType": "agency",
  "sellerRating": 0.0,
  "sellerReviewsCount": 0,
  "sellerSince": "На Авито с YYYY года",
  "viewsCount": 0,
  "attributes": {
    "Sample attribute key": "Sample value",
    "Another attribute key": "Another value"
  }
}
```

### Plan requirement

Avito accepts traffic from residential connections only. The free Apify plan does not include the Residential proxy add-on.

- **Apify Starter, Scale, or higher**: Residential proxy is included. Use the prefilled `proxy.useApifyProxy = true, apifyProxyGroups = ["RESIDENTIAL"]`.
- **Apify Free**: bring your own residential proxy via `proxy.proxyUrls`. Datacenter proxies will be rejected by the upstream edge.

For best results, leave the country code empty so the actor picks the cleanest available exit on each rotation. Per-page bandwidth averages 1.2 MB; a 100-listing run typically uses 30-50 MB of residential traffic.

# Actor input Schema

## `mode` (type: `string`):

Pick how you want to find listings. 'Search by filters' resolves a region + category + filters into a search URL automatically. 'Direct URLs' takes one or more avito.ru URLs you have already copy-pasted from your browser.

## `regions` (type: `array`):

Region slugs (Search mode only). Examples: 'moskva', 'sankt-peterburg', 'rossiya' (all of Russia). Multiple regions are scraped sequentially. Default: moskva.

## `category` (type: `string`):

Top-level category. Pick the kind of listings you want.

## `dealType` (type: `string`):

Sale or Rent. Only applies to property categories (apartments, houses, rooms, garages, commercial, land). Ignored for other categories. Avito only exposes two top-level deal types per category; the slugs are 'prodam' (sale) and 'sdam' (rent, long-term).

## `query` (type: `string`):

Optional text query (matches titles and descriptions). E.g. 'tesla', 'iPhone 15', 'студия у метро'.

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

Minimum price in rubles. Leave empty for no minimum.

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

Maximum price in rubles. Leave empty for no maximum.

## `sortBy` (type: `string`):

How to order results.

## `ownerOnly` (type: `boolean`):

If true, exclude agency / professional sellers, return only private (С/Собственник) postings.

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

Avito.ru search/category URLs to scrape (URL mode only). Multi-URL supported. Filter-mode fields are ignored. Pagination starts at the page in the URL and walks forward.

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

Maximum pages to paginate per region/URL. Avito returns ~50-60 listings per page; Avito caps SERP at page 100 for most categories.

## `maxListings` (type: `integer`):

Hard global cap on total listings written to the dataset across ALL searches (every region in search mode, every URL in URL mode). The actor stops as soon as this number is reached. Set 0 for unlimited (subject to maxPages).

## `fetchDetails` (type: `boolean`):

If true (default), each listing's detail page is fetched to enrich with the 21-key attributes dict (floor, ceilings, balcony type, parking, etc.), full photo gallery, view counts, and seller stats — 38 total fields. Lean mode (false) skips detail fetches and returns 27 of 38 fields from the SERP card alone (including full description, address, metro, photos, badges, rooms, area, floor) and runs ~8x faster. Disable for speed-sensitive or high-volume scrapes.

## `proxy` (type: `object`):

Default: Apify Proxy with the datacenter pool — works for most runs and is ~17x cheaper bandwidth than residential. RECOMMENDED: switch to RESIDENTIAL if you hit sustained rejections, run high-volume scrapes, or need maximum reliability. Add 'RESIDENTIAL' to apifyProxyGroups to enable it.

## Actor input object example

```json
{
  "mode": "search",
  "regions": [
    "moskva"
  ],
  "category": "kvartiry",
  "dealType": "prodam",
  "sortBy": "default",
  "ownerOnly": false,
  "urls": [
    "https://www.avito.ru/moskva/kvartiry/prodam"
  ],
  "maxPages": 1000,
  "maxListings": 20,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "regions": [
        "moskva"
    ],
    "urls": [
        "https://www.avito.ru/moskva/kvartiry/prodam"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/avito-ru-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 = {
    "regions": ["moskva"],
    "urls": ["https://www.avito.ru/moskva/kvartiry/prodam"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/avito-ru-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 '{
  "regions": [
    "moskva"
  ],
  "urls": [
    "https://www.avito.ru/moskva/kvartiry/prodam"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/avito-ru-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Avito RU $1💰 URL | Keyword Filters | Enriched Output",
        "description": "From $1/1k. Pull structured listing data from avito.ru by region, category, or direct URL. Supports filters and auto-pagination. Returns 25+ fields per listing, including price, full address, metro details, images, posting date, seller type, and verification badges.",
        "version": "3.8",
        "x-build-id": "XjB6VYhsb11JyHZl8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~avito-ru-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-avito-ru-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/abotapi~avito-ru-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-avito-ru-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/abotapi~avito-ru-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-avito-ru-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "🎯 Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Pick how you want to find listings. 'Search by filters' resolves a region + category + filters into a search URL automatically. 'Direct URLs' takes one or more avito.ru URLs you have already copy-pasted from your browser.",
                        "default": "search"
                    },
                    "regions": {
                        "title": "Regions",
                        "type": "array",
                        "description": "Region slugs (Search mode only). Examples: 'moskva', 'sankt-peterburg', 'rossiya' (all of Russia). Multiple regions are scraped sequentially. Default: moskva.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "kvartiry",
                            "doma_dachi_kottedzhi",
                            "komnaty",
                            "garazhi_i_mashinomesta",
                            "kommercheskaya_nedvizhimost",
                            "zemelnye_uchastki",
                            "avtomobili",
                            "mototsikly_i_mototehnika",
                            "gruzoviki_i_spectehnika",
                            "vodnyy_transport",
                            "zapchasti_i_aksessuary",
                            "rabota",
                            "uslugi",
                            "predlozheniya_uslug",
                            "rezyume",
                            "vakansii",
                            "bytovaya_elektronika",
                            "telefony",
                            "noutbuki",
                            "audio_i_video",
                            "dlya_doma_i_dachi",
                            "mebel_i_interer",
                            "hobbi_i_otdyh",
                            "zhivotnye",
                            "lichnye_veschi",
                            "odezhda_obuv_aksessuary",
                            "detskaya_odezhda_i_obuv",
                            "tovary_dlya_detey_i_igrushki",
                            "shops",
                            "gotovyy_biznes_i_oborudovanie"
                        ],
                        "type": "string",
                        "description": "Top-level category. Pick the kind of listings you want.",
                        "default": "kvartiry"
                    },
                    "dealType": {
                        "title": "Deal type",
                        "enum": [
                            "any",
                            "prodam",
                            "sdam"
                        ],
                        "type": "string",
                        "description": "Sale or Rent. Only applies to property categories (apartments, houses, rooms, garages, commercial, land). Ignored for other categories. Avito only exposes two top-level deal types per category; the slugs are 'prodam' (sale) and 'sdam' (rent, long-term).",
                        "default": "prodam"
                    },
                    "query": {
                        "title": "Free text search",
                        "type": "string",
                        "description": "Optional text query (matches titles and descriptions). E.g. 'tesla', 'iPhone 15', 'студия у метро'."
                    },
                    "minPrice": {
                        "title": "Min price (₽)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in rubles. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max price (₽)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in rubles. Leave empty for no maximum."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "default",
                            "date_desc",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How to order results.",
                        "default": "default"
                    },
                    "ownerOnly": {
                        "title": "Private sellers only",
                        "type": "boolean",
                        "description": "If true, exclude agency / professional sellers, return only private (С/Собственник) postings.",
                        "default": false
                    },
                    "urls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Avito.ru search/category URLs to scrape (URL mode only). Multi-URL supported. Filter-mode fields are ignored. Pagination starts at the page in the URL and walks forward.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum pages to paginate per region/URL. Avito returns ~50-60 listings per page; Avito caps SERP at page 100 for most categories.",
                        "default": 1000
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard global cap on total listings written to the dataset across ALL searches (every region in search mode, every URL in URL mode). The actor stops as soon as this number is reached. Set 0 for unlimited (subject to maxPages).",
                        "default": 20
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "If true (default), each listing's detail page is fetched to enrich with the 21-key attributes dict (floor, ceilings, balcony type, parking, etc.), full photo gallery, view counts, and seller stats — 38 total fields. Lean mode (false) skips detail fetches and returns 27 of 38 fields from the SERP card alone (including full description, address, metro, photos, badges, rooms, area, floor) and runs ~8x faster. Disable for speed-sensitive or high-volume scrapes.",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Default: Apify Proxy with the datacenter pool — works for most runs and is ~17x cheaper bandwidth than residential. RECOMMENDED: switch to RESIDENTIAL if you hit sustained rejections, run high-volume scrapes, or need maximum reliability. Add 'RESIDENTIAL' to apifyProxyGroups to enable it."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
