# 2GIS $1💰 Extract Phones, Emails, Reviews & Locations (`abotapi/2gis-places-scraper`) Actor

From $1/1K. Extract business and place data from 2GIS.com at scale. Get names, addresses, phones, emails, websites, social links, opening hours, ratings, reviews, photos, coordinates, and 80+ fields per place. Supports all regions covered by 2GIS with fast, low-cost extraction.

- **URL**: https://apify.com/abotapi/2gis-places-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Lead generation, Automation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 2GIS Places Scraper (Phones, Emails, Reviews)

Extract places from 2GIS at scale: names, addresses, phones, emails, websites, social links, per-day opening hours, ratings, reviews, photos, coordinates, and 80+ fields per place. Works across Russia, Kazakhstan, Uzbekistan, Kyrgyzstan, Azerbaijan, Georgia, Armenia, Belarus, the UAE, Saudi Arabia, Qatar, Kuwait, Bahrain, Oman, Cyprus, Czechia, Italy, Chile and every other region 2GIS covers. One flexible search mode, a URL mode, a fast JSON pipeline, and a low running cost.

### Why this scraper

- **80+ fields per place**, including every contact channel split out individually (primary phone, all phones, email, website, WhatsApp, Telegram, Instagram, VK, and more).
- **One flexible search**: combine a WHAT (queries and/or categories) with a WHERE (city, coordinates with a radius, or a map-area bounding box) in a single mode, plus a separate URL mode for direct 2GIS links or IDs. Every field is optional and they work together.
- **Reviews on demand**: pull full review text, author, rating, date, source (2GIS or Flamp), photos, and the official reply.
- **Structured opening hours**: all seven days, each with an explicit open or closed status, plus a ready-to-read summary string.
- **Runs on free datacenter proxy**: no premium proxy required, which keeps every run cheap and fast.
- **Nothing dropped**: the full upstream contact, attribute, and administrative blocks are passed through verbatim alongside the flat fields.

### Data you get

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

| Field | Example |
| --- | --- |
| name | Sample Cafe |
| rating | 4.8 |
| reviewCount | 0 |
| phone | +70000000000 |
| phones | ["+70000000000"] |
| email | contact@example.com |
| website | http://example.com |
| whatsapp | https://wa.me/70000000000 |
| telegram | https://t.me/example |
| instagram | https://instagram.com/example |
| vk | https://vk.com/example |
| fullAddress | City, Sample Street, 1 |
| city | Sample City |
| district | Sample District |
| street | Sample Street |
| houseNumber | 1 |
| postcode | 000000 |
| latitude | 55.0000 |
| longitude | 37.0000 |
| primaryRubric | Cafes |
| rubrics | ["Cafes", "Coffee shops"] |
| nameExtension | cafe |
| orgRating | 4.7 |
| orgReviewCount | 0 |
| flampRating | 4.8 |
| nearestStations | [{"id": "0000", "distanceMeters": 300}] |
| badges | [{"text": "Award winner", "type": "award"}] |
| floorCount | 2 |
| isPromoted | false |
| isAdvertised | false |
| is24x7 | false |
| hoursText | Mon: 09:00-21:00; Tue: 09:00-21:00; ... |
| photos | ["https://cdn.example.com/0000.jpg"] |
| orgName | Sample Org |
| orgBranchCount | 1 |
| isPromoted | false |
| url | https://2gis.ru/city/firm/00000000 |

Review records (when `maxReviews` is above zero) are written to the same dataset with `recordType` set to `review`:

| Field | Example |
| --- | --- |
| recordType | review |
| placeId | 00000000 |
| placeName | Sample Cafe |
| rating | 5 |
| text | Full review text appears here. |
| authorName | Jane Doe |
| authorPhotoUrl | https://cdn.example.com/profile/0000.jpg |
| authorReviewsCount | 0 |
| dateCreated | 2026-01-01T00:00:00.000Z |
| likesCount | 0 |
| commentsCount | 0 |
| hasOfficialAnswer | true |
| provider | 2gis |
| officialAnswerText | Thank you for your feedback. |
| reviewUrl | https://2gis.ru/moscow/firm/00000000/tab/reviews |
| photos | ["https://cdn.example.com/0000.jpg"] |

### How to use

Search mode combines a WHAT (queries and/or categories) with a WHERE (city, coordinates, or map area). Every field is optional. WHERE precedence: map area beats coordinates beats city.

#### By text query in a city

```json
{
  "mode": "search",
  "query": ["coffee shop", "bakery"],
  "city": "Moscow",
  "maxResults": 200
}
````

#### By category in a city

```json
{
  "mode": "search",
  "categoryQuery": ["Restaurants", "Pharmacies"],
  "city": "Almaty",
  "maxResults": 500
}
```

#### Around coordinates (radius)

```json
{
  "mode": "search",
  "query": ["pizza"],
  "latitude": "55.7558",
  "longitude": "37.6173",
  "radiusMeters": 1000,
  "maxResults": 100
}
```

#### In a map area (bounding box)

```json
{
  "mode": "search",
  "categoryQuery": ["Pharmacies"],
  "bbox": "37.55,55.70,37.70,55.80",
  "maxResults": 300
}
```

#### Everything in an area (no query)

```json
{
  "mode": "search",
  "latitude": "55.7558",
  "longitude": "37.6173",
  "radiusMeters": 500,
  "maxResults": 100
}
```

#### From 2GIS URLs or IDs

```json
{
  "mode": "url",
  "urls": [
    "https://2gis.ru/moscow/firm/70000001063551091",
    "https://2gis.ru/moscow/search/coffee",
    "70000001063551091"
  ],
  "maxReviews": 50
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | string | search | search or url. |
| query | array | \["кофейня"] | WHAT to find, as text. Each query runs separately. Optional. |
| categoryQuery | array | \[] | WHAT to find, as category names. Optional, combines with query. |
| city | string | Москва | WHERE, by city. Ignored if coordinates or bbox are set. |
| latitude | string | | WHERE, center latitude. Set with longitude. Overrides city. |
| longitude | string | | Center longitude. Set with latitude. |
| radiusMeters | integer | 1000 | Radius in meters around the point (max 40000). |
| bbox | string | | WHERE, bounding box lon1,lat1,lon2,lat2. Overrides city and coordinates. |
| urls | array | | URL mode: 2GIS place, search, building links, short links, or raw IDs. |
| language | string | ru | Response language for names and content. |
| sortBy | string | relevance | relevance, rating, or distance. |
| minRating | string | | Keep only places at or above this rating. |
| minReviews | integer | | Keep only places with at least this many reviews. |
| onlyWithPhone | boolean | false | Skip places without a phone. |
| onlyWithWebsite | boolean | false | Skip places without a website. |
| skipAds | boolean | false | Skip promoted entries. |
| maxReviews | integer | 0 | Reviews per place. 0 disables review fetching. |
| reviewsSort | string | date\_edited | Order of fetched reviews. |
| reviewsProvider | string | all | Keep all sources, 2gis only, or flamp only. |
| reviewsRating | string | all | Keep all, only positive (4-5), or only negative (1-3). |
| reviewsMinRating | string | | Keep only reviews at or above this star rating. |
| reviewsWithAnswer | boolean | false | Keep only reviews that have an official reply. |
| reviewsStartDate | string | | Keep only reviews created on or after YYYY-MM-DD. |
| reviewsKeyword | string | | Keep only reviews whose text contains this phrase. |
| includePhotos | boolean | true | Include photo URLs in place records. |
| maxResults | integer | 10 | Total places across all queries (shared fairly across them). 0 = unlimited. |
| proxy | object | Apify datacenter | Proxy configuration. |

### Output example

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

```json
{
  "recordType": "place",
  "id": "00000000",
  "name": "Sample Cafe",
  "url": "https://2gis.ru/city/firm/00000000",
  "rating": 4.8,
  "reviewCount": 0,
  "primaryRubric": "Cafes",
  "rubrics": ["Cafes", "Coffee shops"],
  "phone": "+70000000000",
  "phones": ["+70000000000"],
  "email": "contact@example.com",
  "website": "http://example.com",
  "whatsapp": "https://wa.me/70000000000",
  "telegram": "https://t.me/example",
  "instagram": "https://instagram.com/example",
  "vk": "https://vk.com/example",
  "fullAddress": "City, Sample Street, 1",
  "country": "Sample Country",
  "region": "Sample Region",
  "city": "Sample City",
  "district": "Sample District",
  "street": "Sample Street",
  "houseNumber": "1",
  "postcode": "000000",
  "latitude": 55.0000,
  "longitude": 37.0000,
  "is24x7": false,
  "hoursText": "Mon: 09:00-21:00; Tue: 09:00-21:00; Wed: 09:00-21:00; Thu: 09:00-21:00; Fri: 09:00-22:00; Sat: 10:00-22:00; Sun: closed",
  "hours": {
    "Monday": { "status": "open", "intervals": [{ "from": "09:00", "to": "21:00" }] },
    "Sunday": { "status": "closed", "intervals": [] }
  },
  "photos": ["https://cdn.example.com/0000.jpg"],
  "photoCount": 1,
  "orgName": "Sample Org",
  "orgBranchCount": 1,
  "isPromoted": false,
  "attributesByTag": { "food_service_food_european": "European cuisine" }
}
```

### Plan requirement

This actor runs on the default Apify datacenter proxy, which is available on every plan including the free tier, so there is no premium proxy requirement to get started. Residential proxy is optional and only useful for very large repeated runs; when selected, the actor rotates the exit country (your chosen country first, then nearby ones) on a rejected connection and fails over to a backup connection after repeated failures, so a single flagged exit does not stall a run. The 2GIS platform itself caps a single query near 3000 results, so to gather more places for a city use several narrower queries, categories, or map areas. Reviews and photos are optional and only add work when you enable them.

# Actor input Schema

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

search = find places by query, category, city, coordinates, or map area (any combination). url = scrape specific 2GIS links or IDs.

## `query` (type: `array`):

WHAT to find, as free text, for example coffee shop, dentist, hotel. Each query runs separately. Optional: leave empty (and no categories) to return every place in the chosen area.

## `categoryQuery` (type: `array`):

WHAT to find, as category names, for example Restaurants, Pharmacies, Car repair. Each is matched against the 2GIS category tree and runs separately. Optional, and combine freely with queries.

## `city` (type: `string`):

Where to look, by city name, for example Moscow, Москва, Almaty, Dubai. Ignored if you provide coordinates or a map area.

## `latitude` (type: `string`):

Search around a center point. Latitude, for example 55.7558. Provide together with longitude. Overrides city.

## `longitude` (type: `string`):

Center longitude, for example 37.6173. Provide together with latitude.

## `radiusMeters` (type: `integer`):

Search radius around the center point, in meters. Max 40000. Only used when latitude and longitude are set.

## `bbox` (type: `string`):

Rectangle: lon1,lat1,lon2,lat2 (south-west corner then north-east corner), for example 37.55,55.70,37.70,55.80. Overrides city and coordinates.

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

Response language for names and content.

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

Result ordering. Distance only applies when searching around coordinates; otherwise it falls back to relevance.

## `minRating` (type: `string`):

Keep only places with rating at or above this value (0 to 5). Leave blank for no filter.

## `minReviews` (type: `integer`):

Keep only places with at least this many reviews. Leave blank for no filter.

## `onlyWithPhone` (type: `boolean`):

Skip places that have no phone number.

## `onlyWithWebsite` (type: `boolean`):

Skip places that have no website.

## `skipAds` (type: `boolean`):

Skip advertising or promoted entries.

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

Paste 2GIS links: place pages (/firm/ID), searches (/search/query), buildings (/inside/ID), short links (go.2gis.com), or raw numeric firm IDs. Multiple supported. Used only when mode = url.

## `maxReviews` (type: `integer`):

How many reviews to fetch per place. 0 = do not fetch reviews. Reviews are pushed as separate records. Fetching reviews adds an extra request per place.

## `reviewsSort` (type: `string`):

Order of fetched reviews.

## `reviewsProvider` (type: `string`):

Which review source to keep: all, 2GIS only, or Flamp only.

## `reviewsRating` (type: `string`):

Keep all reviews, only positive (4 to 5 stars), or only negative (1 to 3 stars).

## `reviewsMinRating` (type: `string`):

Keep only reviews at or above this star rating (1 to 5). Leave blank for no limit.

## `reviewsWithAnswer` (type: `boolean`):

Keep only reviews that have an official reply from the place.

## `reviewsStartDate` (type: `string`):

Keep only reviews created on or after this date (YYYY-MM-DD). Leave blank for no limit.

## `reviewsKeyword` (type: `string`):

Keep only reviews whose text contains this word or phrase. Leave blank for no filter.

## `includePhotos` (type: `boolean`):

Include photo URLs available in the place record.

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

Maximum total places across all queries / URLs. 0 = unlimited (capped at the 2GIS per-query ceiling of about 3000).

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

2GIS APIs work on datacenter proxy, which is the cheapest and fastest option. Residential is optional for very large runs.

## Actor input object example

```json
{
  "mode": "search",
  "query": [
    "кофейня"
  ],
  "categoryQuery": [],
  "city": "Москва",
  "radiusMeters": 1000,
  "language": "ru",
  "sortBy": "relevance",
  "onlyWithPhone": false,
  "onlyWithWebsite": false,
  "skipAds": false,
  "urls": [
    "https://2gis.ru/moscow/firm/70000001063551091"
  ],
  "maxReviews": 0,
  "reviewsSort": "date_edited",
  "reviewsProvider": "all",
  "reviewsRating": "all",
  "reviewsWithAnswer": false,
  "includePhotos": true,
  "maxResults": 10,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `places` (type: `string`):

Individual place records with 80+ fields including contacts, per-day hours, ratings, attributes and coordinates. Review records (when enabled) are added to the same dataset with a recordType of review.

## `output` (type: `string`):

Run summary with total places, reviews, pages fetched, duration and rate.

# 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 = {
    "query": [
        "кофейня"
    ],
    "categoryQuery": [],
    "city": "Москва",
    "latitude": "",
    "longitude": "",
    "radiusMeters": 1000,
    "bbox": "",
    "minRating": "",
    "urls": [
        "https://2gis.ru/moscow/firm/70000001063551091"
    ],
    "maxReviews": 0,
    "reviewsMinRating": "",
    "reviewsStartDate": "",
    "reviewsKeyword": "",
    "maxResults": 10,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "query": ["кофейня"],
    "categoryQuery": [],
    "city": "Москва",
    "latitude": "",
    "longitude": "",
    "radiusMeters": 1000,
    "bbox": "",
    "minRating": "",
    "urls": ["https://2gis.ru/moscow/firm/70000001063551091"],
    "maxReviews": 0,
    "reviewsMinRating": "",
    "reviewsStartDate": "",
    "reviewsKeyword": "",
    "maxResults": 10,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "query": [
    "кофейня"
  ],
  "categoryQuery": [],
  "city": "Москва",
  "latitude": "",
  "longitude": "",
  "radiusMeters": 1000,
  "bbox": "",
  "minRating": "",
  "urls": [
    "https://2gis.ru/moscow/firm/70000001063551091"
  ],
  "maxReviews": 0,
  "reviewsMinRating": "",
  "reviewsStartDate": "",
  "reviewsKeyword": "",
  "maxResults": 10,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/2gis-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "2GIS $1💰 Extract Phones, Emails, Reviews & Locations",
        "description": "From $1/1K. Extract business and place data from 2GIS.com at scale. Get names, addresses, phones, emails, websites, social links, opening hours, ratings, reviews, photos, coordinates, and 80+ fields per place. Supports all regions covered by 2GIS with fast, low-cost extraction.",
        "version": "1.0",
        "x-build-id": "0Prq5P0tkj31ygmXw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~2gis-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-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/abotapi~2gis-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-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/abotapi~2gis-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "search = find places by query, category, city, coordinates, or map area (any combination). url = scrape specific 2GIS links or IDs.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "WHAT to find, as free text, for example coffee shop, dentist, hotel. Each query runs separately. Optional: leave empty (and no categories) to return every place in the chosen area.",
                        "default": [
                            "кофейня"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryQuery": {
                        "title": "Categories",
                        "type": "array",
                        "description": "WHAT to find, as category names, for example Restaurants, Pharmacies, Car repair. Each is matched against the 2GIS category tree and runs separately. Optional, and combine freely with queries.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City (WHERE)",
                        "type": "string",
                        "description": "Where to look, by city name, for example Moscow, Москва, Almaty, Dubai. Ignored if you provide coordinates or a map area.",
                        "default": "Москва"
                    },
                    "latitude": {
                        "title": "Latitude (WHERE)",
                        "type": "string",
                        "description": "Search around a center point. Latitude, for example 55.7558. Provide together with longitude. Overrides city."
                    },
                    "longitude": {
                        "title": "Longitude (WHERE)",
                        "type": "string",
                        "description": "Center longitude, for example 37.6173. Provide together with latitude."
                    },
                    "radiusMeters": {
                        "title": "Radius (meters)",
                        "minimum": 1,
                        "maximum": 40000,
                        "type": "integer",
                        "description": "Search radius around the center point, in meters. Max 40000. Only used when latitude and longitude are set.",
                        "default": 1000
                    },
                    "bbox": {
                        "title": "Map area / bounding box (WHERE)",
                        "type": "string",
                        "description": "Rectangle: lon1,lat1,lon2,lat2 (south-west corner then north-east corner), for example 37.55,55.70,37.70,55.80. Overrides city and coordinates."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "ru",
                            "en",
                            "ar",
                            "kk",
                            "ky",
                            "ka",
                            "az",
                            "cs",
                            "it",
                            "uz"
                        ],
                        "type": "string",
                        "description": "Response language for names and content.",
                        "default": "ru"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "rating",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Result ordering. Distance only applies when searching around coordinates; otherwise it falls back to relevance.",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "type": "string",
                        "description": "Keep only places with rating at or above this value (0 to 5). Leave blank for no filter."
                    },
                    "minReviews": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only places with at least this many reviews. Leave blank for no filter."
                    },
                    "onlyWithPhone": {
                        "title": "Only places with a phone",
                        "type": "boolean",
                        "description": "Skip places that have no phone number.",
                        "default": false
                    },
                    "onlyWithWebsite": {
                        "title": "Only places with a website",
                        "type": "boolean",
                        "description": "Skip places that have no website.",
                        "default": false
                    },
                    "skipAds": {
                        "title": "Skip promoted places",
                        "type": "boolean",
                        "description": "Skip advertising or promoted entries.",
                        "default": false
                    },
                    "urls": {
                        "title": "2GIS URLs or IDs",
                        "type": "array",
                        "description": "Paste 2GIS links: place pages (/firm/ID), searches (/search/query), buildings (/inside/ID), short links (go.2gis.com), or raw numeric firm IDs. Multiple supported. Used only when mode = url.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many reviews to fetch per place. 0 = do not fetch reviews. Reviews are pushed as separate records. Fetching reviews adds an extra request per place.",
                        "default": 0
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "date_edited",
                            "date_created",
                            "rating",
                            "friends"
                        ],
                        "type": "string",
                        "description": "Order of fetched reviews.",
                        "default": "date_edited"
                    },
                    "reviewsProvider": {
                        "title": "Reviews source",
                        "enum": [
                            "all",
                            "2gis",
                            "flamp"
                        ],
                        "type": "string",
                        "description": "Which review source to keep: all, 2GIS only, or Flamp only.",
                        "default": "all"
                    },
                    "reviewsRating": {
                        "title": "Reviews rating filter",
                        "enum": [
                            "all",
                            "positive",
                            "negative"
                        ],
                        "type": "string",
                        "description": "Keep all reviews, only positive (4 to 5 stars), or only negative (1 to 3 stars).",
                        "default": "all"
                    },
                    "reviewsMinRating": {
                        "title": "Reviews minimum rating",
                        "type": "string",
                        "description": "Keep only reviews at or above this star rating (1 to 5). Leave blank for no limit."
                    },
                    "reviewsWithAnswer": {
                        "title": "Only reviews with an official answer",
                        "type": "boolean",
                        "description": "Keep only reviews that have an official reply from the place.",
                        "default": false
                    },
                    "reviewsStartDate": {
                        "title": "Reviews from date",
                        "type": "string",
                        "description": "Keep only reviews created on or after this date (YYYY-MM-DD). Leave blank for no limit."
                    },
                    "reviewsKeyword": {
                        "title": "Reviews keyword",
                        "type": "string",
                        "description": "Keep only reviews whose text contains this word or phrase. Leave blank for no filter."
                    },
                    "includePhotos": {
                        "title": "Include place photos",
                        "type": "boolean",
                        "description": "Include photo URLs available in the place record.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max places (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total places across all queries / URLs. 0 = unlimited (capped at the 2GIS per-query ceiling of about 3000).",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "2GIS APIs work on datacenter proxy, which is the cheapest and fastest option. Residential is optional for very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
