# Avito Scraper (`server0/avito-scraper`) Actor

Scrapes search-result listings from Avito (avito.ru) by keyword, category, region and price range.

- **URL**: https://apify.com/server0/avito-scraper.md
- **Developed by:** [SilentHunter](https://apify.com/server0) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Scraper (Apify Actor)

Scrapes **search-result listings** from [Avito](https://www.avito.ru) (avito.ru). You provide a
keyword, optional category/region and a price range; the actor builds the search URL, paginates
through results and stores each listing card in the dataset.

> Scope: search-result cards only. It does **not** open individual ad pages and does **not**
> collect phone numbers.

### Features

- **Structured search** — by keyword, region, category and price range, with sorting.
- **Or paste URLs** — feed ready-made Avito search/category URLs via `startUrls`.
- **Hybrid engine** — Chrome-TLS-fingerprinted HTTP (impit) for speed, with a headless-browser
  fallback used only to resolve Avito's category redirect; pagination then runs over HTTP.
- **Rich data from Avito's own JSON** — exact price, posted date, GPS coordinates, category,
  photo count and seller rating; robust to HTML/markup changes.
- **Public data only** — listing cards, no phone numbers and no personal data.

### How it works

Avito renders search results **client-side**. A plain keyword search (`/{region}?q=...`) returns a
JavaScript shell with no listings, then redirects — via in-page JS — to a canonical category URL
(`/all/{category}/mobile-<code>?...`) that **is** server-side rendered with the cards. The actor uses a
hybrid engine that exploits this:

1. **Fast HTTP pass** — `CheerioCrawler` over **impit** (real Chrome **TLS + HTTP/2 fingerprint**, no
   browser; this is what gets past Avito's Cloudflare TLS fingerprinting). If the URL already resolves
   to a rendered results page — e.g. a results URL you pasted into `startUrls` straight from your
   browser — the cards are parsed here directly, fast and cheap.
2. **Browser pass** — `PlaywrightCrawler` (headless Chromium with browser fingerprints). A bare keyword
   search only yields the JS shell over HTTP, so it is handed to the browser, which runs Avito's
   redirect and extracts the **first** page of cards. It then captures the resolved category URL and
   hands the remaining pages **back to the fast impit pass** — so the browser is used only for the
   one-time redirect resolution and pagination runs over HTTP.

Listings are parsed from the page's **embedded catalog JSON** (Avito's server-rendered state), which is
more robust than HTML scraping and carries richer fields (exact price, posted timestamp, coordinates,
category, photo count, seller rating). DOM selectors remain as a fallback. Because the data comes from
that JSON, the browser pass **blocks images, fonts, CSS and third-party trackers** — cutting page weight
and per-IP rate-limit pressure.

Both passes rotate identities via Crawlee's `SessionPool`, retire blocked sessions, and are rate-limited
(`maxRequestsPerMinute`) to avoid hammering a single IP.

> Tip: to skip the browser entirely, paste the **results URL from your browser's address bar** (after
> Avito has redirected to the category page) into `startUrls` — those pages are server-rendered, so the
> fast HTTP pass handles them on its own.

### Input

You must provide **either** `keyword` **or** `startUrls`.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `keyword` | string | yes* | Search query (the `q` parameter). Required unless `startUrls` is set. |
| `startUrls` | array | yes* | Ready-made Avito search URLs (copy from your browser). Take precedence over `keyword`/`region`/`category` and bypass Avito's category redirect. |
| `region` | string | no | Region slug from the Avito URL. Default `rossiya` (all Russia). |
| `category` | string | no | Category slug. Empty = all categories. |
| `priceMin` | integer | no | Lower bound of the price range (→ `pmin`). |
| `priceMax` | integer | no | Upper bound of the price range (→ `pmax`). |
| `maxItems` | integer | no | Max listings to collect. Default `100`. |
| `sort` | string | no | Result order: `default`, `date` (newest), `priceAsc` (cheaper first), `priceDesc` (expensive first). Maps to Avito's `s` param. |
| `proxyConfiguration` | object | yes* | Proxy. Prefilled to Apify Residential, country `RU`. |

\* Russian residential proxies are effectively required — see below.

#### Region / category slugs

Use the slugs exactly as they appear in an Avito URL, e.g.:

- Regions: `rossiya`, `moskva`, `sankt-peterburg`, `novosibirsk`, `ekaterinburg`
- Categories: `avtomobili`, `kvartiry`, `telefony`, `noutbuki`, `tovary_dlya_kompyutera`

Tip: open Avito in a browser, set your filters, and copy the path segments from the resulting URL.

#### Example input

```json
{
  "keyword": "iphone 15",
  "region": "moskva",
  "category": "telefony",
  "priceMin": 30000,
  "priceMax": 70000,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "RU"
  }
}
````

### Output

Each dataset item (fields are read from Avito's embedded catalog JSON):

```json
{
  "id": "7685094754",
  "title": "iPhone 17, 256 ГБ",
  "price": 53490,
  "priceString": "53 490 ₽",
  "currency": "RUB",
  "url": "https://www.avito.ru/ekaterinburg/telefony/iphone_17_256_gb_7685094754",
  "location": "Свердловская обл., Екатеринбург",
  "locationId": 654070,
  "lat": 56.830664,
  "lng": 60.589794,
  "categoryId": 84,
  "categorySlug": "telefony",
  "categoryName": "Телефоны",
  "postedDate": "2026-05-31T20:05:23.000Z",
  "postedTimestamp": 1780257923000,
  "imageUrl": "https://...",
  "photoCount": 7,
  "description": "iPhone 17, 256 ГБ. Оригинальный, запечатанный…",
  "sellerRating": 4.9,
  "sellerReviews": "3 252 отзыва",
  "isVerified": false,
  "isNew": false,
  "isPromoted": false,
  "category": "telefony",
  "region": "rossiya",
  "keyword": "iphone",
  "scrapedAt": "2026-05-31T12:00:00.000Z"
}
```

`category`/`region`/`keyword` echo your **search** input; `categorySlug`/`locationId`/etc. describe the
**listing** itself. Some fields can be empty for certain listings (e.g. `location`/`lat`/`lng` when Avito
hides the exact address — `locationId` is always present). If the embedded JSON is ever unavailable, the
DOM fallback fills the core fields (`id`, `title`, `price`, `url`, `location`, `imageUrl`).

### Proxies — important

Avito sits behind Cloudflare and rate-limits per IP. The TLS impersonation above defeats
*fingerprint*-based detection, but **IP reputation and per-IP rate limits still matter** — so the
proxy pool is decisive.

- **Apify Residential, country `RU`** — the prefilled default. Apify Proxy has no selectable "mobile"
  group, so residential is the strongest Apify-native option for Avito (its pool does include some
  mobile IPs, but they can't be isolated).
- **The pool must be large.** A handful of IPs gets detected and banned quickly; Avito's limits are
  aggressive. Prefer a big rotating residential pool.
- **Custom proxies for true mobile IPs.** Carrier (mobile) IPs are rate-limited by Avito far less
  aggressively, but Apify doesn't offer them as a group. To use them, pick "Custom proxies" in the
  proxy editor and paste URLs from an external mobile provider (e.g. BrightData mobile). Datacenter
  IPs can work *only* with a very large rotating pool.

Without a decent Russian IP pool the actor will mostly hit "Доступ ограничен" block pages regardless
of the engine.

### Running locally

```bash
npm install
npx playwright install chromium   ## only needed for the browser fallback pass
apify login                       ## required to use Apify residential proxies locally
apify run --purge                 ## reads input from storage/key_value_stores/default/INPUT.json
```

Results land in `storage/datasets/default/`.

### Deploy

```bash
apify push
```

### FAQ

**Why are Russian proxies required?** Avito is geofenced and Cloudflare-protected; without a Russian
IP pool you mostly get "Доступ ограничен" block pages. See *Proxies* above.

**Why does it launch a browser?** A bare keyword search returns a JS shell and Avito resolves the
category client-side. The browser runs that redirect once, then the fast HTTP pass takes over. Paste
a resolved category URL into `startUrls` to skip the browser entirely.

**Does it collect personal data?** No. Only public listing fields (title, price, location, photos,
rating, etc.). No phone numbers and no seller contact details.

**Which regions and categories are supported?** Any — use the slugs from an Avito URL (see above).
Default region is `rossiya` (all Russia), all categories.

**Why are some `location` fields empty?** Avito hides the exact address for certain listings;
`locationId` is always present.

### Legal note

Avito's Terms of Service restrict automated scraping. This actor collects **only public listing
fields and no personal data** (no phone numbers, no seller contact details). You are responsible for
ensuring your use complies with Avito's terms and applicable law; keep request volumes modest.

# Actor input Schema

## `keyword` (type: `string`):

Поисковый запрос (параметр q на Авито). Обязателен, если не заданы startUrls.

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

Опционально. Готовые URL страниц результатов Авито (скопируйте из браузера). Если заданы, имеют приоритет над keyword/регионом/категорией и обходят редирект категории.

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

Slug региона из URL Авито: rossiya (вся Россия), moskva, sankt-peterburg, и т.д.

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

Опционально. Slug категории: avtomobili, kvartiry, telefony, и т.д. Пусто = все категории.

## `priceMin` (type: `integer`):

Нижняя граница коридора цен (→ pmin). Опционально.

## `priceMax` (type: `integer`):

Верхняя граница коридора цен (→ pmax). Опционально.

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

Сколько объявлений собрать максимум.

## `sort` (type: `string`):

Порядок сортировки результатов (параметр s на Авито).

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

Для Авито нужны российские прокси. По умолчанию — Apify Residential, страна RU. У Apify нет отдельной мобильной группы; для истинно мобильных IP выберите «Custom proxies» и вставьте URL своего провайдера (напр. BrightData mobile). Датацентровые блокируются.

## Actor input object example

```json
{
  "keyword": "iphone 15",
  "region": "rossiya",
  "maxItems": 100,
  "sort": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

## `items` (type: `string`):

All collected Avito listing cards.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("server0/avito-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    } }

# Run the Actor and wait for it to finish
run = client.actor("server0/avito-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call server0/avito-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Avito Scraper",
        "description": "Scrapes search-result listings from Avito (avito.ru) by keyword, category, region and price range.",
        "version": "0.1",
        "x-build-id": "VpOyImcewOyHjAGZ7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/server0~avito-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-server0-avito-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/server0~avito-scraper/runs": {
            "post": {
                "operationId": "runs-sync-server0-avito-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/server0~avito-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-server0-avito-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": {
                    "keyword": {
                        "title": "Ключевое слово / Keyword",
                        "type": "string",
                        "description": "Поисковый запрос (параметр q на Авито). Обязателен, если не заданы startUrls."
                    },
                    "startUrls": {
                        "title": "Стартовые URL / Start URLs",
                        "type": "array",
                        "description": "Опционально. Готовые URL страниц результатов Авито (скопируйте из браузера). Если заданы, имеют приоритет над keyword/регионом/категорией и обходят редирект категории.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "region": {
                        "title": "Регион / Region (slug)",
                        "type": "string",
                        "description": "Slug региона из URL Авито: rossiya (вся Россия), moskva, sankt-peterburg, и т.д.",
                        "default": "rossiya"
                    },
                    "category": {
                        "title": "Категория / Category (slug)",
                        "type": "string",
                        "description": "Опционально. Slug категории: avtomobili, kvartiry, telefony, и т.д. Пусто = все категории."
                    },
                    "priceMin": {
                        "title": "Цена от / Price min",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Нижняя граница коридора цен (→ pmin). Опционально."
                    },
                    "priceMax": {
                        "title": "Цена до / Price max",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Верхняя граница коридора цен (→ pmax). Опционально."
                    },
                    "maxItems": {
                        "title": "Макс. объявлений / Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Сколько объявлений собрать максимум.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Сортировка / Sorting",
                        "enum": [
                            "default",
                            "date",
                            "priceAsc",
                            "priceDesc"
                        ],
                        "type": "string",
                        "description": "Порядок сортировки результатов (параметр s на Авито).",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Прокси / Proxy",
                        "type": "object",
                        "description": "Для Авито нужны российские прокси. По умолчанию — Apify Residential, страна RU. У Apify нет отдельной мобильной группы; для истинно мобильных IP выберите «Custom proxies» и вставьте URL своего провайдера (напр. BrightData mobile). Датацентровые блокируются.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```