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

Search 2GIS business directory across 11 country domains (RU, KZ, UAE, UZ, BY, AM, AZ, GE, TJ, KG, .com). Extract place name, address, postcode, structured address, rating, category, reviews, photos, contacts, working hours, and social links via the Catalog API.

- **URL**: https://apify.com/crawlerbros/2gis-places-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 17 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

## 2GIS Places Scraper

Extract business listings, restaurants, hotels, shops, and services from **2GIS** — the leading map and business directory for Russia, UAE, Kazakhstan, and 10+ countries. Get place names, addresses, GPS coordinates, ratings, phone numbers, websites, working hours, reviews, and photos.

### What is 2GIS?

[2GIS](https://2gis.com) is a mapping and business directory platform used by millions across Russia, the UAE, Kazakhstan, Kyrgyzstan, Uzbekistan, Belarus, Armenia, Azerbaijan, Georgia, and Tajikistan. It lists millions of businesses with detailed information including contacts, hours, and user reviews.

### What This Actor Does

- Searches 2GIS for any category (restaurants, hotels, shops, services, etc.) in any supported city
- Accepts both **2GIS search URLs** and free-text **query + city** inputs
- Returns structured data for every matching place
- Optionally fetches phone numbers, emails, websites, social media links, reviews, and photos

### Input

| Field | Description | Default |
|-------|-------------|---------|
| Start URLs | 2GIS search URLs to scrape (e.g. `https://2gis.ae/dubai/search/restaurant`) | Required |
| Search Queries | Search terms to run against each city — overrides URL's embedded query | — |
| Location | City name when not using URLs (e.g. "Dubai", "Moscow", "Almaty") | — |
| Max Items | Maximum places per query+location combination | 50 |
| 2GIS API Key | API key for higher limits. Use `demo` for up to ~50 results for free | `demo` |
| Include Contacts | Fetch phones, website, email, social links | Yes |
| Include Reviews | Fetch user reviews per place — requires a registered API key | No |
| Include Photos | Include photo URLs — requires a registered API key | No |
| Sort By | `relevance`, `rating`, or `distance` | relevance |
| Has Website Only | Only return places with a website | No |
| Has Photos Only | Only return places with photos | No |
| Open Now Only | Only return currently open places | No |
| Category IDs | Filter by 2GIS rubric/category IDs | — |

#### How to Get a Start URL

1. Go to [2gis.ae](https://2gis.ae) (or [2gis.ru](https://2gis.ru), [2gis.kz](https://2gis.kz), etc.)
2. Search for a category in any city (e.g. "restaurant" in Dubai)
3. Copy the URL from your browser address bar
4. Paste it into the Start URLs field

**Example URLs:**
- `https://2gis.ae/dubai/search/restaurant`
- `https://2gis.ru/moscow/search/кофе`
- `https://2gis.kz/almaty/search/hotel`

### Output

Each place is one JSON record. Fields appear only when the data exists — no null values.

| Field | Description | Example |
|-------|-------------|---------|
| `id` | 2GIS place ID | `"70000001035586092"` |
| `name` | Place name | `"Nobu Restaurant"` |
| `city` | City | `"Dubai"` |
| `country` | Country | `"UAE"` |
| `address` | Street address (single line) | `"Al Wasl Rd, 10"` |
| `street` | Street name only (when API exposes structured address) | `"Al Wasl Rd"` |
| `houseNumber` | Building number (when API exposes structured address) | `"10"` |
| `postcode` | Postal code (when API exposes it) | `"00000"` |
| `addressComment` | Floor, entrance, etc. | `"3rd floor"` |
| `latitude` | GPS latitude | `25.1972` |
| `longitude` | GPS longitude | `55.2744` |
| `categories` | Place categories | `["Restaurant", "Japanese"]` |
| `categoryIds` | Category IDs | `["281", "6780"]` |
| `rating` | Average rating (1–5) | `4.7` |
| `ratingCategory` | Bucketed rating: `"Excellent"` (≥4.5), `"Good"` (≥4.0), `"Average"` (≥3.0), `"Poor"` (<3.0) | `"Excellent"` |
| `reviewCount` | Total review count | `312` |
| `workingHours` | Opening hours by day | `[{"day": "Mon", "hours": [{"from": "10:00", "to": "22:00"}]}]` |
| `phones` | Phone numbers | `["+971 4 560 1234"]` |
| `website` | Website URL | `"https://nobu.ae"` |
| `emails` | Email addresses | `["info@nobu.ae"]` |
| `socialLinks` | Social media links | `{"instagram": "https://instagram.com/nobu_dubai"}` |
| `reviews` | User reviews (when enabled) | `[{"rating": 5, "text": "..."}]` |
| `photos` | Photo URLs (when enabled) | `["https://disk.2gis.com/..."]` |
| `url` | 2GIS place page URL | `"https://2gis.ae/dubai/firm/..."` |
| `scrapedAt` | Scrape timestamp (UTC) | `"2026-04-22T10:00:00Z"` |

### Supported Countries and Domains

| Domain | Country |
|--------|---------|
| 2gis.ae | UAE |
| 2gis.ru | Russia |
| 2gis.kz | Kazakhstan |
| 2gis.kg | Kyrgyzstan |
| 2gis.uz | Uzbekistan |
| 2gis.by | Belarus |
| 2gis.am | Armenia |
| 2gis.az | Azerbaijan |
| 2gis.ge | Georgia |
| 2gis.tj | Tajikistan |

### FAQ

**Do I need a proxy?**
No. The 2GIS API is publicly accessible without a proxy. The actor connects directly from Apify servers.

**Do I need an API key?**
No signup is required. The built-in `demo` key works out of the box for up to ~50 results per search. For more results, register a free key at [platform.2gis.ru](https://platform.2gis.ru) (no credit card required) and enter it in the API Key field.

**How many results can I get?**
With the `demo` key: up to ~50 results per search query+city combination. With a registered free key: hundreds or thousands depending on how many places exist for that query in the city.

**Can I search in Russian or Arabic?**
Yes. Paste 2GIS URLs with Cyrillic or Arabic queries directly into Start URLs, or type a query in any language in the Search Queries field alongside a Location (e.g. Location: "Москва", Query: "кофе").

**Can I scrape reviews?**
Reviews require a registered API key (the demo key does not support the reviews endpoint). Enable "Include Reviews", set "Max Reviews per Place", and provide your registered key in the API Key field.

**Can I get photos?**
Photo URLs require a registered API key. Enable "Include Photos" and provide your registered key.

**Can I filter by category?**
Yes. Use the Category IDs (Rubric IDs) field. Find IDs by browsing 2GIS categories at 2gis.com/catalog and noting the ID in the URL.

**What cities are supported?**
Any city listed on 2GIS — over 500 cities across 10+ countries in Russia, CIS, and the Middle East.

**Why are some fields missing for some places?**
2GIS listings vary in completeness. The actor only outputs fields that contain real data — no null or empty values appear in the output.

**Can I scrape a specific place directly?**
Yes. Paste a 2GIS firm URL (e.g. `https://2gis.ae/dubai/firm/nobu/70000001035586092`) into Start URLs to fetch data for that specific place.

# Actor input Schema

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

One or more 2GIS search URLs. Go to 2gis.ae (or 2gis.ru, 2gis.kz) and search for a category in a city, then copy the URL and paste it here.
## `query` (type: `array`):

Search terms to run against each URL's city, or against locationQuery. Example: ["restaurant", "hotel", "coffee"]. If empty, uses the query embedded in each Start URL.
## `locationQuery` (type: `string`):

City or area name when not using Start URLs. Example: "Dubai", "Moscow", "Almaty".
## `maxItems` (type: `integer`):

Maximum number of places to scrape per query+location combination.
## `apiKey` (type: `string`):

2GIS Catalog API key. The built-in "demo" key works up to ~50 results per search with no signup. For more results, register a free key at platform.2gis.ru.
## `includeContacts` (type: `boolean`):

Fetch phone numbers, website, emails, and social media links. No extra API call — included in the main search request.
## `includeReviews` (type: `boolean`):

Fetch reviews for each place. Requires a registered API key (demo key does not support the reviews endpoint). Adds one API call per place.
## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to fetch per place when Include Reviews is enabled.
## `includePhotos` (type: `boolean`):

Include photo URLs for each place. Note: photo URLs are not available with the demo API key.
## `maxPhotosPerPlace` (type: `integer`):

Maximum number of photo URLs to include per place.
## `sortBy` (type: `string`):

Sort order for search results.
## `filterHasWebsite` (type: `boolean`):

Only return places that have a website listed.
## `filterHasPhotos` (type: `boolean`):

Only return places that have photos.
## `filterOpenNow` (type: `boolean`):

Only return places currently open.
## `rubricIds` (type: `array`):

Filter by 2GIS category IDs. Example: ["281"] for restaurants. Find IDs at 2gis.com/catalog.

## Actor input object example

```json
{
  "startUrls": [
    "https://2gis.ae/dubai/search/restaurant"
  ],
  "maxItems": 5,
  "apiKey": "demo",
  "includeContacts": true,
  "includeReviews": false,
  "maxReviewsPerPlace": 10,
  "includePhotos": false,
  "maxPhotosPerPlace": 5,
  "sortBy": "relevance",
  "filterHasWebsite": false,
  "filterHasPhotos": false,
  "filterOpenNow": false
}
````

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://2gis.ae/dubai/search/restaurant"
    ],
    "maxItems": 5,
    "apiKey": "demo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "startUrls": ["https://2gis.ae/dubai/search/restaurant"],
    "maxItems": 5,
    "apiKey": "demo",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "2GIS Places Scraper",
        "description": "Search 2GIS business directory across 11 country domains (RU, KZ, UAE, UZ, BY, AM, AZ, GE, TJ, KG, .com). Extract place name, address, postcode, structured address, rating, category, reviews, photos, contacts, working hours, and social links via the Catalog API.",
        "version": "0.0",
        "x-build-id": "vJz9ybDu8oB7IFZgX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~2gis-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~2gis-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~2gis-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more 2GIS search URLs. Go to 2gis.ae (or 2gis.ru, 2gis.kz) and search for a category in a city, then copy the URL and paste it here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search terms to run against each URL's city, or against locationQuery. Example: [\"restaurant\", \"hotel\", \"coffee\"]. If empty, uses the query embedded in each Start URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or area name when not using Start URLs. Example: \"Dubai\", \"Moscow\", \"Almaty\"."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of places to scrape per query+location combination.",
                        "default": 50
                    },
                    "apiKey": {
                        "title": "2GIS API Key",
                        "type": "string",
                        "description": "2GIS Catalog API key. The built-in \"demo\" key works up to ~50 results per search with no signup. For more results, register a free key at platform.2gis.ru."
                    },
                    "includeContacts": {
                        "title": "Include Contacts",
                        "type": "boolean",
                        "description": "Fetch phone numbers, website, emails, and social media links. No extra API call — included in the main search request.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Fetch reviews for each place. Requires a registered API key (demo key does not support the reviews endpoint). Adds one API call per place.",
                        "default": false
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max Reviews per Place",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per place when Include Reviews is enabled.",
                        "default": 10
                    },
                    "includePhotos": {
                        "title": "Include Photos",
                        "type": "boolean",
                        "description": "Include photo URLs for each place. Note: photo URLs are not available with the demo API key.",
                        "default": false
                    },
                    "maxPhotosPerPlace": {
                        "title": "Max Photos per Place",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of photo URLs to include per place.",
                        "default": 5
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "rating",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "relevance"
                    },
                    "filterHasWebsite": {
                        "title": "Has Website Only",
                        "type": "boolean",
                        "description": "Only return places that have a website listed.",
                        "default": false
                    },
                    "filterHasPhotos": {
                        "title": "Has Photos Only",
                        "type": "boolean",
                        "description": "Only return places that have photos.",
                        "default": false
                    },
                    "filterOpenNow": {
                        "title": "Open Now Only",
                        "type": "boolean",
                        "description": "Only return places currently open.",
                        "default": false
                    },
                    "rubricIds": {
                        "title": "Category IDs (Rubric IDs)",
                        "type": "array",
                        "description": "Filter by 2GIS category IDs. Example: [\"281\"] for restaurants. Find IDs at 2gis.com/catalog.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```