# 2GIS Places Scraper (`fetch_cat/2gis-places-scraper`) Actor

Extract public 2GIS place listings, ratings, review counts, categories, addresses, coordinates when visible, and diagnostics from search queries or 2GIS search URLs.

- **URL**: https://apify.com/fetch\_cat/2gis-places-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, Travel, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 place 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 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

## 2GIS Places Scraper

Extract public 2GIS place listings from search queries or public 2GIS search URLs. The Actor saves structured rows with names, URLs, addresses, categories, ratings, review counts when visible, and run diagnostics for troubleshooting.

Use it for local business research, lead lists, location monitoring, market mapping, and automation workflows that need CSV, JSON, Excel, API, or MCP access to 2GIS data.

### At a glance

- **Primary job**: Search 2GIS by keyword and city, then export public place rows.
- **Input**: Search queries, a location, optional public 2GIS URLs, filters, and a result limit.
- **Output**: One dataset row per public 2GIS place plus diagnostic KV records.
- **Best for**: Lead generation, competitor research, branch discovery, category monitoring, and enrichment pipelines.

### Common workflows

- **Lead generation**: Search categories such as restaurants, dentists, clinics, cafes, repair shops, or hotels in a target city.
- **Market research**: Compare categories, ratings, addresses, and review counts across neighborhoods or regions.
- **Monitoring**: Schedule repeat runs for the same query/location and compare new rows or rating changes.
- **Automation**: Send dataset exports to a CRM, spreadsheet, webhook, API client, or MCP-enabled AI workflow.

### Ready-to-run examples

- [Dubai restaurants lead list from 2GIS](https://apify.com/fetch_cat/2gis-places-scraper/examples/dubai-restaurants-lead-list) — verified with 12 items.
- [Almaty dentists search listings from 2GIS](https://apify.com/fetch_cat/2gis-places-scraper/examples/almaty-dentists-search-listings) — verified with 7 items.
- [URL-based Dubai restaurants search on 2GIS](https://apify.com/fetch_cat/2gis-places-scraper/examples/url-based-dubai-restaurants-search) — verified with 12 items.

### What data can you extract?

| Field | Description |
| --- | --- |
| `id` | 2GIS place or branch identifier when available. |
| `title` | Public place name. |
| `url` | Public 2GIS place URL. |
| `query` | Search query that produced the row. |
| `locationQuery` | City or region used for query searches. |
| `domain` | 2GIS domain used for the source route. |
| `address` | Public address text. |
| `city` | Input city or region context. |
| `rubrics` / `category` | Public category labels. |
| `rating` | Visible rating value, when present. |
| `reviewsCount` | Visible review/rating count, when present. |
| `sourceStatus`, `sourceMode`, `blocked`, `emptyPage` | Diagnostics for source handling. |
| `scrapedAt` | ISO timestamp for the row. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Search queries | `queries` | Business categories or keywords to search. | `["Restaurants", "Dentists"]` |
| Location | `locationQuery` | City or region used in query URLs. | `"dubai"` |
| 2GIS URLs | `startUrls` | Public 2GIS search or place URLs. | `[{"url":"https://2gis.ae/dubai/search/Restaurants."}]` |
| Maximum places | `maxItems` | Cap saved rows and control spend. | `10` |
| 2GIS domain | `domain` | Regional 2GIS domain for query searches. | `"2gis.ae"` |
| Language | `language` | Preferred page language where supported. | `"en"` |
| Sort by | `sortBy` | Preferred order when supported by the source route. | `"relevance"` |
| Minimum rating | `minRating` | Keep places at or above a rating threshold when visible. | `4` |
| Dedupe places by | `dedupeBy` | Suppress duplicates across queries and URLs. | `"idOrUrl"` |

### Example input

```json
{
  "queries": ["Restaurants"],
  "locationQuery": "dubai",
  "domain": "2gis.ae",
  "language": "en",
  "maxItems": 10,
  "dedupeBy": "idOrUrl"
}
````

### Example output

```json
{
  "id": "70000001055149461",
  "title": "Laffah",
  "url": "https://2gis.ae/dubai/firm/70000001055149461",
  "query": "Restaurants",
  "locationQuery": "dubai",
  "domain": "2gis.ae",
  "address": "Flamingo Building, Sheikh Khalifa Bin Zayed road, Dubai",
  "city": "dubai",
  "category": "Arabic restaurant",
  "rating": 5,
  "reviewsCount": 45,
  "sourceStatus": "ok",
  "sourceMode": "http-static",
  "scrapedAt": "2026-07-22T13:03:04.000Z"
}
```

### Pricing

This Actor uses pay-per-event pricing. You are charged `$0.02` when a run starts and a tiered price for each place row saved to the dataset.

| Tier | Per saved place |
| --- | --- |
| Free | `$0.003` |
| Bronze | `$0.0026` |
| Silver | `$0.0022` |
| Gold | `$0.0018` |
| Platinum | `$0.0014` |
| Diamond | `$0.001` |

### Tips for best results

- **Start small**: Use `maxItems: 10` until output quality and pricing are verified.
- **Choose the matching region**: Use `2gis.ae` for UAE routes, `2gis.kz` for Kazakhstan, and `2gis.ru` for Russia.
- **Keep searches focused**: Specific categories and cities usually produce cleaner data than broad keywords.
- **Use public inputs**: Account, dashboard, login, and business-management URLs are rejected.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/2gis-places-scraper").call({
  queries: ["Restaurants"],
  locationQuery: "dubai",
  domain: "2gis.ae",
  maxItems: 10
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/2gis-places-scraper").call(run_input={
    "queries": ["Restaurants"],
    "locationQuery": "dubai",
    "domain": "2gis.ae",
    "maxItems": 10,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~2gis-places-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Restaurants"],"locationQuery":"dubai","domain":"2gis.ae","maxItems":10}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/2gis-places-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/2gis-places-scraper"
    }
  }
}
```

Example prompt: "Run 2GIS Places Scraper for restaurants in Dubai with maxItems 10 and summarize the highest-rated places."

### Limits and caveats

- **Coverage**: 2GIS availability, public page layout, language, and regional routes vary by country and city.
- **Freshness**: Source data can change after a run finishes.
- **Optional fields**: Some addresses, ratings, review counts, coordinates, or categories may be unavailable on public search pages.
- **Rate limits**: Public endpoints may throttle large or frequent runs.

### Legality and responsible use

Process only data that you are allowed to access. Follow website terms, Apify's terms, and applicable laws.

### Related actors

- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder)
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder)
- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

Some 2GIS pages do not expose every field publicly. The Actor leaves unavailable fields empty instead of guessing.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL.

# Actor input Schema

## `queries` (type: `array`):

Business categories or keywords to search on 2GIS, for example Restaurants or dentists. Use this when you do not provide start URLs.

## `locationQuery` (type: `string`):

City or region to search, for example dubai or almaty.

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

Public 2GIS search or place URLs. Account, dashboard, login, and business-management URLs are rejected.

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

Maximum number of place rows to save across all queries and URLs.

## `domain` (type: `string`):

Regional 2GIS domain to use for query searches. Auto chooses a tested domain from your location where possible.

## `language` (type: `string`):

Preferred page language where the regional 2GIS route supports it.

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

Preferred ordering when supported by 2GIS routes. Unsupported values are recorded in diagnostics and the default order is used.

## `minRating` (type: `number`):

Only emit places with this rating or higher when a rating is available. Leave empty to keep all places.

## `dedupeBy` (type: `string`):

How to suppress duplicate places across queries and pages within one run.

## Actor input object example

```json
{
  "queries": [
    "Restaurants"
  ],
  "locationQuery": "dubai",
  "startUrls": [
    {
      "url": "https://2gis.ae/dubai/search/Restaurants."
    }
  ],
  "maxItems": 10,
  "domain": "2gis.ae",
  "language": "en",
  "sortBy": "relevance",
  "dedupeBy": "idOrUrl"
}
```

# 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 = {
    "queries": [
        "Restaurants"
    ],
    "locationQuery": "dubai",
    "startUrls": [
        {
            "url": "https://2gis.ae/dubai/search/Restaurants."
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/2gis-places-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 = {
    "queries": ["Restaurants"],
    "locationQuery": "dubai",
    "startUrls": [{ "url": "https://2gis.ae/dubai/search/Restaurants." }],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/2gis-places-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 '{
  "queries": [
    "Restaurants"
  ],
  "locationQuery": "dubai",
  "startUrls": [
    {
      "url": "https://2gis.ae/dubai/search/Restaurants."
    }
  ]
}' |
apify call fetch_cat/2gis-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "2GIS Places Scraper",
        "description": "Extract public 2GIS place listings, ratings, review counts, categories, addresses, coordinates when visible, and diagnostics from search queries or 2GIS search URLs.",
        "version": "0.1",
        "x-build-id": "ROVPWxmOCJq7pP33f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~2gis-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-2gis-places-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/fetch_cat~2gis-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-2gis-places-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/fetch_cat~2gis-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-2gis-places-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Business categories or keywords to search on 2GIS, for example Restaurants or dentists. Use this when you do not provide start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search, for example dubai or almaty.",
                        "default": "dubai"
                    },
                    "startUrls": {
                        "title": "2GIS URLs",
                        "type": "array",
                        "description": "Public 2GIS search or place URLs. Account, dashboard, login, and business-management URLs are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of place rows to save across all queries and URLs.",
                        "default": 10
                    },
                    "domain": {
                        "title": "2GIS domain",
                        "enum": [
                            "auto",
                            "2gis.ae",
                            "2gis.com",
                            "2gis.kz",
                            "2gis.ru"
                        ],
                        "type": "string",
                        "description": "Regional 2GIS domain to use for query searches. Auto chooses a tested domain from your location where possible.",
                        "default": "2gis.ae"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "auto",
                            "en",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Preferred page language where the regional 2GIS route supports it.",
                        "default": "en"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "rating",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "Preferred ordering when supported by 2GIS routes. Unsupported values are recorded in diagnostics and the default order is used.",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only emit places with this rating or higher when a rating is available. Leave empty to keep all places."
                    },
                    "dedupeBy": {
                        "title": "Dedupe places by",
                        "enum": [
                            "idOrUrl",
                            "id",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to suppress duplicate places across queries and pages within one run.",
                        "default": "idOrUrl"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
