# 2GIS Reviews Scraper API (`dami_studio/2gis-reviews-scraper`) Actor

Scrape every review on any 2GIS place: star rating, full text, author, date, photos and the owner’s reply, plus the place’s aggregate rating and review count. Paste place URLs or search a city. $0.50 per 1,000 reviews - the lowest price of any 2GIS reviews scraper on the Apify Store.

- **URL**: https://apify.com/dami\_studio/2gis-reviews-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Reviews Scraper API

Pulls customer reviews out of [2GIS](https://2gis.ru) — the maps and business directory used across Russia, Kazakhstan, Uzbekistan and the rest of the CIS, plus the UAE and Cyprus.

Paste a 2GIS place URL, or search a city. You get one row per review: star rating, the full review text, who wrote it, when, any photos they attached, and the business owner's reply — plus the place's own aggregate rating and total review count on every row.

**$0.50 per 1,000 reviews.** That is the lowest price of any 2GIS reviews scraper on the Apify Store. The next cheapest dedicated one is $0.70 / 1,000; the popular one is $1.00 / 1,000 with a $0.007 charge every time you press Start.

### What a row looks like

```json
{
  "reviewId": "264464544",
  "rating": 5,
  "text": "Вкусно очень, все съели, ничего не осталось, даже фото сделать не успели",
  "textLength": 72,
  "authorName": "Natalia Kim",
  "authorId": "30843856",
  "authorPublicId": "dc53b75b17f54dc7b0349fd40326bcde",
  "authorReviewCount": 8,
  "authorIsVerified": false,
  "dateCreated": "2026-08-03T18:20:27.790655+07:00",
  "dateEdited": "2026-08-03T18:21:20.137947+07:00",
  "likesCount": 1,
  "commentsCount": 1,
  "photoCount": 0,
  "photoUrls": [],
  "officialAnswerText": "Спасибо за доверие! Приятно узнать, что вам нравится...",
  "officialAnswerDate": "2026-08-03T19:10:29.872356+07:00",
  "officialAnswerBy": "Додо Пицца, сеть пиццерий",
  "source": "2gis",
  "placeId": "70000001044357973",
  "placeName": "Додо Пицца, сеть пиццерий",
  "placeCategory": "Пиццерии",
  "placeAddress": "Москва, Театральный проезд, 5",
  "placeCity": "Москва",
  "placeCountry": "Россия",
  "placeLatitude": 55.759891,
  "placeLongitude": 37.625011,
  "placeRating": 4.9,
  "placeReviewCount": 292,
  "placeUrl": "https://2gis.ru/moscow/firm/70000001044357973",
  "reviewUrl": "https://2gis.ru/moscow/firm/70000001044357973/tab/reviews",
  "position": 1,
  "scrapedAt": "2026-08-07T21:59:16.328Z"
}
```

Every row carries the place it belongs to, so you can dump the dataset straight into a spreadsheet without a join. Rows that came from a search term also get a `searchQuery` field telling you which term found them.

### Input

The simplest job — one place, its 100 newest reviews:

```json
{
  "startUrls": ["https://2gis.ru/moscow/firm/70000001044357973"],
  "maxReviewsPerPlace": 100
}
```

Reviews for every restaurant a search finds:

```json
{
  "searchQueries": ["ресторан"],
  "city": "Moscow",
  "maxPlaces": 25,
  "maxReviewsPerPlace": 200,
  "maxItems": 1000
}
```

| Field | What it does |
|---|---|
| `startUrls` | 2GIS place pages (`https://2gis.ru/moscow/firm/70000001044357973`), the `/tab/reviews` version of the same page, or bare numeric place ids. 2GIS *search* URLs work too — every place the search finds gets scraped. |
| `searchQueries` | Find places by term instead of pasting URLs. Use with `city`. |
| `city` | `Moscow`, `Москва`, `Almaty`, `Dubai` — English or local spelling. A numeric 2GIS city id also works. |
| `maxReviewsPerPlace` | Newest first. Stops one 5,000-review chain from eating the whole budget. |
| `maxItems` | Hard cap across all places. You are charged per review returned. |
| `maxPlaces` | How many places to take from the searches. |
| `sortBy` | `date_created`, `date_edited`, `trust` or `friends` — the four orders 2GIS itself supports. |
| `minRating` / `onlyWithText` | Filters. Anything filtered out is never charged. |
| `locale` | Language for place names and categories. Review text is never translated. |

Run it with no input at all and it returns a single labelled sample row so you can see the shape. That run is not charged.

### How much you get back

2GIS serves every review a place has — there is no depth limit like the one on its place search. Measured on the real thing: `Додо Пицца, Театральный проезд 5` reports 292 reviews and the actor returns all 292, no duplicates, in 6.8 seconds.

From a live 1,000-review run across 7 Moscow restaurants: text on 1,000/1,000, star rating 1,000/1,000, author name 1,000/1,000, date 1,000/1,000, place name and aggregate rating 1,000/1,000. 735 of them had an owner's reply attached, 72 had photos, 199 had at least one like. The star split was 864 five-star, 66 four, 18 three, 7 two, 45 one — so the negative reviews are in there, not filtered away.

Speed: 1,000 reviews across 25 places in about 90 seconds.

### Countries

2GIS is a regional directory, not a global one. It covers Russia, Kazakhstan, Uzbekistan, Kyrgyzstan, Azerbaijan, Belarus, Georgia, Armenia, Tajikistan, Cyprus and the UAE. Reviews were confirmed working in Moscow, Almaty, Tashkent and Dubai. If you need reviews outside that list, 2GIS is the wrong source.

Reviews are written in whatever language the customer used — mostly Russian, even in Dubai.

### Pricing

| Event | When | Price |
|---|---|---|
| Actor start | Once per run | $0.001 |
| Review | Each review row returned | $0.0005 ($0.50 / 1,000) |

Sample rows, error rows, diagnostics and reviews removed by your own `minRating` / `onlyWithText` filters are never charged. A run that finds nothing costs you $0.001.

100 reviews = $0.051. 1,000 reviews = $0.501. 10,000 reviews = $5.001.

For comparison, at the time of writing: `zen-studio/2gis-reviews-scraper` charges $0.001 per review plus $0.007 every start, `getascraper/2gis-reviews-scraper` $0.00088 plus $0.00005, `scrapesmith/2gis-reviews-scraper` $0.0007 plus $0.005. A handful of *places* scrapers bill reviews as a $0.0005 add-on, but only after you have also paid them $0.003–$0.005 for the place itself, so no one actually gets reviews cheaper than this.

### How it works

The reviews tab on a 2GIS place page is fed by a service of its own, separate from the maps catalog: `public-api.reviews.2gis.com`. It answers plain JSON with no anti-bot challenge, authenticated by the public key 2GIS ships in its own front-end config. This actor reads that key live at start-up, so a key rotation on 2GIS's side does not need a redeploy — and there is a built-in fallback if the lookup ever fails.

Paging is a date cursor, not a page number, so a walk down a busy place never repeats a review or skips one.

Place names, addresses and coordinates come from the 2GIS catalog API in the same run, which is why every review row already knows which business it belongs to.

No browser, no residential proxy, no headless Chrome. Requests are made with a real Chrome TLS fingerprint (`impit`), which is what keeps both APIs answering consistently from a datacenter.

### Limits, stated honestly

- **No rating sort.** 2GIS offers exactly four orders — newest by post date, newest by edit date, its own "trust" order, and friends-first. If you want only the 1-star reviews, pull them and filter with `minRating`; there is no way to ask 2GIS for them directly.
- **Author names are display names.** 2GIS does not expose reviewer emails or profile links, so neither does this actor. You get the name, a stable id and how many reviews that person has written.
- **Review permalinks do not exist.** `reviewUrl` points at the place's reviews tab, which is the closest thing 2GIS has. `reviewId` is stable, so use that as your key.
- **Photos are URLs, not files.** `photoUrls` gives you the full-size image links; downloading them is your side.
- **The public web key can rotate.** The actor re-reads it on every run, so a rotation is usually invisible. If 2GIS ever revokes it outright, runs return an uncharged `KEY_REJECTED` diagnostic instead of silently returning nothing.
- **A place with no reviews returns a diagnostic, not a row.** Uncharged.
- **Not a global directory.** See the country list above.

### FAQ

**Can I scrape 2GIS reviews without an API key of my own?**
Yes. This actor uses the public key 2GIS's own website uses. You do not register anything with 2GIS.

**How do I get all reviews for one business?**
Paste its 2GIS URL into `startUrls` and set `maxReviewsPerPlace` above the review count shown on the page. 2GIS serves the whole history.

**Can I monitor reviews for a list of my locations?**
Yes — put all the place URLs in `startUrls`, set `sortBy` to `date_created` and `maxReviewsPerPlace` to something small like 20, and run it on a schedule. `reviewId` tells you which ones are new.

**Does it return the business's reply to a review?**
Yes, in `officialAnswerText` with its date. About three quarters of reviews in a Moscow restaurant sample had one.

**Does it return the star rating of the business itself?**
Yes. `placeRating` and `placeReviewCount` are on every row, read from 2GIS's reviews service rather than the cached catalog figure.

**Can I filter to negative reviews only?**
Not on 2GIS's side. Pull them and use `minRating`, or filter the dataset afterwards. Reviews you filter out are not charged.

**Does it work outside Russia?**
Yes, anywhere 2GIS operates — verified in Almaty, Tashkent and Dubai. The reviews themselves are usually still in Russian.

**Which is the cheapest 2GIS reviews scraper on Apify?**
This one, at $0.50 per 1,000 reviews. Compare the pricing tab of any other 2GIS reviews actor.

# Actor input Schema

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

The places whose reviews you want. Paste 2GIS place pages (https://2gis.ru/moscow/firm/70000001044357973), the reviews tab of a place, or bare numeric place ids. 2GIS search pages (https://2gis.ru/moscow/search/кафе) also work — every place the search finds gets scraped.

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

Optional. Find places by search term and scrape the reviews of each one. Use with "City" below. 2GIS is a Russian/CIS directory, so local-language terms return more.

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

Which city the search terms apply to. English or local spelling both work ("Moscow", "Москва", "Almaty", "Dubai"). A numeric 2GIS city id works too. Ignored when you only paste place URLs.

## `maxReviewsPerPlace` (type: `integer`):

Newest first. 2GIS serves every review a place has, so this is what stops a 5,000-review chain from eating your whole budget.

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

Hard cap across all places. You are charged per review returned.

## `maxPlaces` (type: `integer`):

How many places to take from the search terms / search URLs. Pasted place URLs count towards this too.

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

How 2GIS orders the reviews before this actor takes the first N. There is no rating sort on 2GIS's side — use "Minimum rating" below to keep only the stars you care about.

## `minRating` (type: `integer`):

Keep only reviews of this many stars or more. 0 keeps everything. Set 1 to drop reviews that carry text but no star rating.

## `onlyWithText` (type: `boolean`):

Skip star-only reviews that have no written text.

## `locale` (type: `string`):

Optional 2GIS locale for place names and categories. Review text is always returned exactly as the author wrote it — nothing is translated. Leave as Automatic unless you specifically need another language.

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

Optional. The actor already uses its own egress; leave this alone unless you need to exit from a specific network.

## Actor input object example

```json
{
  "startUrls": [
    "https://2gis.ru/moscow/firm/70000001044357973"
  ],
  "searchQueries": [],
  "maxReviewsPerPlace": 100,
  "maxItems": 500,
  "maxPlaces": 10,
  "sortBy": "date_created",
  "minRating": 0,
  "onlyWithText": false,
  "locale": "",
  "proxyConfiguration": {
    "useApifyProxy": 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.ru/moscow/firm/70000001044357973"
    ],
    "searchQueries": [],
    "city": "",
    "maxReviewsPerPlace": 100,
    "maxItems": 500,
    "maxPlaces": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/2gis-reviews-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.ru/moscow/firm/70000001044357973"],
    "searchQueries": [],
    "city": "",
    "maxReviewsPerPlace": 100,
    "maxItems": 500,
    "maxPlaces": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/2gis-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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.ru/moscow/firm/70000001044357973"
  ],
  "searchQueries": [],
  "city": "",
  "maxReviewsPerPlace": 100,
  "maxItems": 500,
  "maxPlaces": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dami_studio/2gis-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/2gis-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/UnJFB4mDPJRWPsOG5/builds/11F5Dt8bpVgerWbTd/openapi.json