# Yandex Images Scraper (`crawlerbros/yandex-images-scraper`) Actor

Scrape image search results from Yandex Images (yandex.ru/images). Returns full image URL, thumbnail, dimensions, source page, and title for each result. Ideal for image SEO research, brand monitoring, and content research on Russian-language sites.

- **URL**: https://apify.com/crawlerbros/yandex-images-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Yandex Images Scraper

Extract image search results from [Yandex Images](https://yandex.ru/images) — the leading image search engine for Russian-language and CIS-market web content, with regional coverage across Russia, Kazakhstan, Belarus, Uzbekistan, Turkmenistan, and an international (English) edition.

### What data does it return?

For each image result you get:

| Field | Description |
|---|---|
| `imageUrl` | Full-resolution image URL |
| `thumbnailUrl` | Thumbnail URL (Yandex CDN) |
| `title` | Image title / alt text |
| `sourceUrl` | Web page where the image appears |
| `sourceDomain` | Domain of the source page |
| `width` / `height` | Image dimensions in pixels |
| `thumbnailWidth` / `thumbnailHeight` | Thumbnail dimensions |
| `query` | The search query that produced this result |
| `position` | Rank within the query's results (1-indexed) |
| `scrapedAt` | Scrape timestamp (ISO 8601 UTC) |

Every field above is only ever included when real data was extracted — no `null`/empty placeholders are ever pushed to the dataset.

### Use cases

- **Image SEO research** — Find what images rank for Russian-language keywords
- **Brand & logo monitoring** — Track visual usage of your brand across Russian and CIS websites
- **Content research** — Discover image sources and publishers for CIS-market topics
- **Stock photo research** — Find imagery indexed on the Russian web for specific topics
- **Freshness monitoring** — Track newly-indexed images for a topic over the last week

### How to use

1. Enter one or more **search queries** (supports Cyrillic and Latin scripts)
2. Set **Max Results** per query (1–500; each page returns ~30 images)
3. Optionally filter by **Image Size**, **Type**, **Color**, **Orientation**, or **Date**
4. Optionally pick a **Region** to search a different Yandex ccTLD
5. Proxy is pre-configured to Apify's free **AUTO** (datacenter) group — no paid add-ons required

#### Example input

```json
{
  "searchQueries": ["Яндекс логотип", "Toyota red car"],
  "maxResults": 60,
  "imageSize": "large",
  "imageType": "photo",
  "orientation": "horizontal",
  "region": "ru",
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example output

```json
{
  "query": "Яндекс логотип",
  "position": 1,
  "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/58/Yandex_icon.svg/3840px-Yandex_icon.svg.png",
  "thumbnailUrl": "https://avatars.mds.yandex.net/i?id=31db23fb37e882f20c3b984958435be25e63ecda-3471343-images-thumbs&n=13",
  "title": "File:Yandex icon.svg - Wikimedia Commons",
  "sourceUrl": "https://commons.wikimedia.org/wiki/File:Yandex_icon.svg?uselang=ru",
  "sourceDomain": "commons.wikimedia.org",
  "width": 3840,
  "height": 3840,
  "thumbnailWidth": 3840,
  "thumbnailHeight": 3840,
  "scrapedAt": "2026-07-20T12:08:56Z"
}
```

### Filters

| Filter | Options | Notes |
|---|---|---|
| Image Size | Any, Small, Medium, Large, Huge | Maps to Yandex's `isize` parameter |
| Image Type | Any, Photo, Clipart, Face, Line art, Demotivator | Maps to `itype` |
| Image Color | Any, Color, Black & white, Red, Orange, Yellow, Green, Blue, Violet, White, Black | Maps to `icolor` |
| Orientation | Any, Horizontal (landscape), Vertical (portrait), Square | Maps to `iorient`; verified to measurably narrow the image aspect-ratio distribution |
| Date | Any time, Past 7 days | Maps to Yandex's `recent` "fresh images" toggle. This is the **only** freshness granularity Yandex Images' own UI exposes — there is no day/month/year range, so we don't fabricate one |
| Region | Russia (yandex.ru), International (yandex.com), Kazakhstan (yandex.kz), Belarus (yandex.by), Uzbekistan (yandex.uz), Turkmenistan (yandex.tm) | Each domain is queried directly; `yandex.com` serves an English UI, the CIS ccTLDs serve Russian |

All filters were verified live against Yandex Images (inspecting the page's own `advancedSearch.filters.active` state and the resulting image dimensions/content) before being wired into the actor — none are guessed.

### Proxy

Yandex Images can show a CAPTCHA to heavy/automated traffic. The actor defaults to Apify's **free AUTO (datacenter) proxy group**, which was verified reliable across every input combination tested (see Testing below) — no paid proxy is required to run this actor on the free plan. If you scrape at high volume and start seeing CAPTCHA warnings in the run log, switch `proxyConfiguration` to a Residential proxy group for extra headroom.

The actor also retries automatically: each search page load gets up to 3 attempts with exponential backoff (10s → 20s → 40s, capped at 90s), rotating to a fresh proxy session on every retry. This recovers from transient network errors, 429/5xx responses, and one-off CAPTCHA challenges. If a query still fails after all retries, the run's status message reports it explicitly instead of silently returning 0 results.

### Regions / multi-market support

Yandex Images is queried directly on the domain you select — `yandex.ru`, `yandex.com`, `yandex.kz`, `yandex.by`, `yandex.uz`, and `yandex.tm` were all verified to return real (non-CAPTCHA) search results from Apify's own datacenter IPs. `yandex.ru` remains the default and the most complete index for Russian-language content; `yandex.com` is the best choice for an English-language UI and international sources.

### Known limitations

- **Reverse image search** is not supported — keyword search only.
- Some `sourceUrl` pages (e.g., certain stock-photo sites) block plain HTTP clients with their own bot protection and return a non-200 status to tools like `curl`, even though the page opens fine in a real browser. This affects only the *page* URL, not the `imageUrl`/`thumbnailUrl` media links, which were verified to resolve directly.
- Results past roughly 400–500 per query become sparse on Yandex's side, matching the actor's 500 cap.

### FAQ

**Can I scrape more than 500 results per query?**
Yandex Images stops returning meaningful results past ~400–500 results. The cap of 500 matches practical limits.

**Does it work without a paid proxy?**
Yes. The default AUTO (datacenter) proxy group is free on every Apify plan and was verified reliable in testing. Residential proxy is available as an opt-in for high-volume use.

**Is reverse image search supported?**
Not currently — keyword search only.

**What languages do the queries support?**
Any language Yandex Images supports — Russian, Kazakh, Uzbek, English, and more.

**What does the "Date" filter actually do?**
It toggles Yandex's own "fresh images" filter, which only supports a single 7-day window — Yandex's own search UI doesn't expose finer date granularity for images, so the actor doesn't invent one.

**Which region should I pick?**
`yandex.ru` (default) has the deepest index for Russian-language and CIS content. Use `yandex.com` for an English-language interface, or the country-specific ccTLD (`kz`/`by`/`uz`/`tm`) if you specifically need that market's locally-tuned results.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more image search queries. e.g. 'Яндекс логотип', 'red Toyota car', 'mountain landscape'.

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

Maximum number of image results to return per query (1–500). 30 = 1 page, 300 = 10 pages.

## `imageSize` (type: `string`):

Filter results by image size.

## `imageType` (type: `string`):

Filter results by image type.

## `imageColor` (type: `string`):

Filter results by dominant color.

## `orientation` (type: `string`):

Filter results by image orientation (landscape/portrait/square).

## `dateFilter` (type: `string`):

Limit results to freshly-indexed images. Yandex Images' UI only exposes a single 'fresh' toggle covering the last 7 days — there is no day/month/year granularity.

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

Yandex regional domain to search on. Each region serves a locally-tuned index and (for yandex.com) an English UI; yandex.ru remains the most complete index for Russian-language content.

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

Proxy settings. AUTO (datacenter) works for light/occasional use; switch to Residential if you see CAPTCHA blocks in the run log on repeated/high-volume use.

## Actor input object example

```json
{
  "searchQueries": [
    "Яндекс логотип"
  ],
  "maxResults": 3,
  "imageSize": "any",
  "imageType": "any",
  "imageColor": "any",
  "orientation": "any",
  "dateFilter": "any",
  "region": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `images` (type: `string`):

Dataset containing all scraped Yandex Images results.

# 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 = {
    "searchQueries": [
        "Яндекс логотип"
    ],
    "maxResults": 3,
    "imageSize": "any",
    "imageType": "any",
    "imageColor": "any",
    "orientation": "any",
    "dateFilter": "any",
    "region": "ru",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/yandex-images-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 = {
    "searchQueries": ["Яндекс логотип"],
    "maxResults": 3,
    "imageSize": "any",
    "imageType": "any",
    "imageColor": "any",
    "orientation": "any",
    "dateFilter": "any",
    "region": "ru",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/yandex-images-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 '{
  "searchQueries": [
    "Яндекс логотип"
  ],
  "maxResults": 3,
  "imageSize": "any",
  "imageType": "any",
  "imageColor": "any",
  "orientation": "any",
  "dateFilter": "any",
  "region": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/yandex-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Images Scraper",
        "description": "Scrape image search results from Yandex Images (yandex.ru/images). Returns full image URL, thumbnail, dimensions, source page, and title for each result. Ideal for image SEO research, brand monitoring, and content research on Russian-language sites.",
        "version": "1.0",
        "x-build-id": "TFmvmtmyuv8CgRo6k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~yandex-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-yandex-images-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/crawlerbros~yandex-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-yandex-images-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/crawlerbros~yandex-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-yandex-images-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "One or more image search queries. e.g. 'Яндекс логотип', 'red Toyota car', 'mountain landscape'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of image results to return per query (1–500). 30 = 1 page, 300 = 10 pages.",
                        "default": 30
                    },
                    "imageSize": {
                        "title": "Image Size",
                        "enum": [
                            "any",
                            "small",
                            "medium",
                            "large",
                            "huge"
                        ],
                        "type": "string",
                        "description": "Filter results by image size.",
                        "default": "any"
                    },
                    "imageType": {
                        "title": "Image Type",
                        "enum": [
                            "any",
                            "photo",
                            "clipart",
                            "face",
                            "lineart",
                            "demotivator"
                        ],
                        "type": "string",
                        "description": "Filter results by image type.",
                        "default": "any"
                    },
                    "imageColor": {
                        "title": "Image Color",
                        "enum": [
                            "any",
                            "color",
                            "bw",
                            "red",
                            "orange",
                            "yellow",
                            "green",
                            "blue",
                            "violet",
                            "white",
                            "black"
                        ],
                        "type": "string",
                        "description": "Filter results by dominant color.",
                        "default": "any"
                    },
                    "orientation": {
                        "title": "Image Orientation",
                        "enum": [
                            "any",
                            "horizontal",
                            "vertical",
                            "square"
                        ],
                        "type": "string",
                        "description": "Filter results by image orientation (landscape/portrait/square).",
                        "default": "any"
                    },
                    "dateFilter": {
                        "title": "Date Filter",
                        "enum": [
                            "any",
                            "week"
                        ],
                        "type": "string",
                        "description": "Limit results to freshly-indexed images. Yandex Images' UI only exposes a single 'fresh' toggle covering the last 7 days — there is no day/month/year granularity.",
                        "default": "any"
                    },
                    "region": {
                        "title": "Region / Domain",
                        "enum": [
                            "ru",
                            "com",
                            "kz",
                            "by",
                            "uz",
                            "tm"
                        ],
                        "type": "string",
                        "description": "Yandex regional domain to search on. Each region serves a locally-tuned index and (for yandex.com) an English UI; yandex.ru remains the most complete index for Russian-language content.",
                        "default": "ru"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. AUTO (datacenter) works for light/occasional use; switch to Residential if you see CAPTCHA blocks in the run log on repeated/high-volume use."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
