# Domclick RU Property Scraper - Listings, Prices & Agent Data (`abotapi/domclick-scraper`) Actor

Extract property listings from domclick.ru, one of Russia’s largest real estate portals. Search by city or use listing/search URLs. Returns 70+ fields including price, area, rooms, floor, address, GPS, metro info, photos, seller and agency details, developer data, discounts, and mortgage flags.

- **URL**: https://apify.com/abotapi/domclick-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 22 total users, 2 monthly users, 89.6% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 listing 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Domclick Scraper: Russian Property Listings with 70+ Fields

Domclick Scraper turns Domclick, one of the largest property portals in Russia, into structured data. Search any city or region with rich filters, or paste Domclick search and listing links directly. Every listing comes back with price, area, rooms, floor, build year, full address, GPS coordinates, metro stations with walking time, the photo gallery, the seller description, and seller and agency details. Turn on extra details for a market valuation estimate, nearby places, and agent deal stats, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **70+ fields per listing.** Price, price per square meter, area, rooms, floor, build year, full address, GPS, metro stations, photos, seller and agency details, verification badges, and new building and developer info.
- **Two ways to start.** Build a search from city, deal type, and filters, or paste Domclick search or listing links directly.
- **All of Russia.** Any city or region name is resolved automatically, or paste an address GUID directly.
- **Sale and rent.** Residential, commercial, and garage categories, plus secondary market flats and new building layouts.
- **Server side filters.** Filter by rooms, price, area, and floor, and sort seven ways, so counts stay accurate.
- **Optional extra details.** A market valuation estimate, nearby points of interest, and agent deal history, added on demand.
- **Built for monitoring.** Incremental mode returns only new, updated, and delisted listings on a schedule, and a refused run fails loudly instead of returning an empty dataset.

### Use Cases

- **Real estate marketplaces and PropTech products:** mirror Domclick sale and rent listings across Russian cities into your own search index.
- **Market research and pricing analysis:** track price, price per square meter, discounts, and mortgage flags across regions and property types over time.
- **New building and developer tracking:** monitor layouts, developer information, and construction end dates for new residential complexes.
- **Lead generation for agents and agencies:** build contact lists from seller and company details, filtered by verification and agency badges.
- **Price and inventory monitoring:** schedule the actor with incremental mode to catch new, updated, and delisted properties without re-downloading everything each time.

### Data You Get

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

| Field | Example |
| --- | --- |
| `id` | `"2077927661"` |
| `url` | `"https://domclick.ru/card/sale__flat__2077927661"` |
| `dealType` / `offerType` | `"sale"` / `"flat"` |
| `price` / `squarePrice` | `34999000` / `466653` |
| `currency` | `"RUB"` |
| `area` / `rooms` | `75` / `2` |
| `floor` / `totalFloors` | `14` / `17` |
| `buildYear` | `2026` |
| `isApartment` | `false` |
| `address` | `"Москва, набережная Примерная, 1 к1"` |
| `latitude` / `longitude` | `55.0000` / `37.0000` |
| `nearestSubway` / `subwayWalkMinutes` | `"Технопарк"` / `12` |
| `subways` | `[{ "name": "Технопарк", "walkMinutes": 12, "lineColors": ["#3EA332"] }]` |
| `description` | `"Full seller description text appears here."` |
| `photoCount` / `photos` | `11` / `["https://img.dmclk.ru/vitrina/owner/00/00/000.jpg"]` |
| `complexName` / `buildingEndYear` | `"Sample Complex"` / `2026` |
| `sellerName` / `isAgency` / `companyName` | `"Agent Name"` / `true` / `"Sample Company"` |
| `isRosreestrApproved` / `isSberCollateral` | `true` / `false` |
| `hasDiscount` / `discountValue` / `hasFamilyMortgage` | `true` / `500000` / `true` |
| `publishedDate` | `"2026-01-01T00:00:00+00:00"` |
| `marketPrice` / `minMarketPrice` / `maxMarketPrice` | `30280000` / `25740000` / `34820000` (when extra details on) |
| `shortAddress` / `addressGuid` / `regionGuid` / `timezone` / `timezoneOffset` | `Москва, Вешняковская улица, 21/26` / address and region identifiers / `Europe/Moscow` / `3` (when extra details on) |
| `priceForYear` / `pricePerM2ForYear` / `renovation` / `source` | `102000000` / `1637239.2` / `Без ремонта` / `agent` (when extra details on) |
| `agentDealsCompleted` / `poiCount` | `31` / `50` (when extra details on) |

Every listing also carries `companyFiasId`, `sellerCasId`, `complexId`, `complexSlug`, `buildingReleased`, `buildingEndQuarter`, `hasPersonalDiscount`, `duplicatesOfferCount`, `tariffName`, `tariffDisplayName`, `isPlacementPaid`, `isExclusive`, `isAuction`, `assignmentSale`, `chatAvailable`, `hasAdvancePayment`, `hasRentCommission`, `transferMortgageRate`, `pessimizationType`, `updatedDate`, `offerRegion`, `offerRegionName`, `subdomain`, `buildingPath`, `localityPath`, `roomsOffered`, `status`, `isSold`, `isAgent`, `isSbolVerified`, `isEsiaVerified`, `hasVideo`, `monthlyPayment`, `rentShortPrice`, `rentLongPrice`, `sellerExperience`, `sellerPhotoUrl`, `query` and `scrapedAt`, plus these companion fields (all `null` when the listing does not carry them): `pricePerM2`, `monthlyMortgage`, `discountPercent`, `mortgageRate`, `lastPriceChange` (`less` or `more`, the direction of the last price change), `sellerVerified`, `seller`, `addressName`, `city`, `regionName`, `tariff`, `isPessimized`, `pessimizationTitle`, `pessimizationText`, `publishedAt`, `updatedAt`, `bigCard`, and, for new building layouts, `layoutId`, `layoutOffersCount`, `minPrice`, `minFloor`, `maxFloor`, `developer`, `developerSlug`, `developerLogo`, `developerOffersCount`, `buildingId`, `buildingName`, plus the complete seller and agency block passed through verbatim as `sellerRaw` and the source building or locality path metadata as `seoRaw`, so the full seller and agency record is always available even where it is not mapped to a named field. This actor does not collect seller phone numbers.

### How to Use

1. Pick a **mode**: `search` (build from city and filters) or `url` (paste Domclick links).
2. In search mode, fill in city, deal type, category, and any filters. In URL mode, paste search or listing links.
3. Turn on **Fetch extra details** if you need the market valuation estimate, nearby places, agent stats and the listing card's own fields (address and region identifiers, timezone, price for a year, price history, renovation, per-station distance), and set **Max listings** and **Max pages** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search one city:**

```json
{
  "mode": "search",
  "locations": ["Москва"],
  "dealType": "sale",
  "category": "living",
  "offerType": "flat",
  "maxListings": 100
}
```

**Search with filters:**

```json
{
  "mode": "search",
  "locations": ["Санкт-Петербург"],
  "dealType": "sale",
  "rooms": ["2", "3"],
  "minPrice": 10000000,
  "maxPrice": 25000000,
  "minArea": 50,
  "sortBy": "price_asc",
  "maxListings": 200
}
```

**Multiple cities with extra details (valuation, nearby places, agent stats):**

```json
{
  "mode": "search",
  "locations": ["Москва", "Сочи", "Казань"],
  "fetchDetails": true,
  "maxPages": 3
}
```

**Paste a search link:**

```json
{
  "mode": "url",
  "urls": [
    "https://domclick.ru/search?deal_type=rent&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553"
  ],
  "maxListings": 50
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/domclick-scraper").call(run_input={"mode": "search", "locations": ["Москва"], "maxListings": 50})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["address"], listing["price"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/domclick-scraper').call({ mode: 'search', locations: ['Москва'], maxListings: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### A pasted listing link returns less than a search

In `url` mode, pasting a Domclick **search** link (`domclick.ru/search?...`) walks the results exactly like search mode and returns full listings. In `url` mode the `urls` field is pre-filled with one example of each supported link shape (sale, rent, commercial, garage, new building layouts, filtered, sorted, paginated and a listing card), so leaving it untouched scrapes those examples; replace them with your own links. Site filter parameters such as `sale_price__gte` and `total_area__gte` in a pasted search link are applied, and a link with `offset=30` or `page=2` starts the walk at that page (a walk that starts past the first page never marks listings as `EXPIRED`). Pasting a single **listing card** link (`domclick.ru/card/...`) is different: the search feed has no lookup by listing id, so the actor builds a minimal record from the listing id and adds the extra-detail fields (market valuation estimate and the listing card's own fields such as the short address, address identifiers, timezone, price for a year and renovation) when they are available. That record is still one pushed row and is billed as a result. Price, area, rooms, floor, photos, and the full seller block are not populated from a card link, because those fields only exist in the search results payload. To get the full field set for a specific property, search for it instead.

#### maxPages, maxListings, and incremental mode

`maxListings` is an overall cap across every target (0 means unlimited); `maxPages` caps result pages per city or URL, about 30 listings each (empty means walk every page, still bounded by `maxListings` and end of catalogue detection). Under **incremental mode**, `maxListings` counts rows returned, not rows examined: a scheduled run keeps walking past listings it has already seen until it fills the quota with genuinely new ones. To make a quiet monitoring run return nothing and cost almost nothing when nothing changed, run uncapped (`maxListings: 0`, `maxPages` empty).

#### Resume and recurring updates

- **`resumeFromRunId`** continues one interrupted, uncapped run in a new run: paste its run or dataset id and listings already collected there (matched by `id`) are skipped, so you only pay for the new ones. A platform migration or a **Resurrect** of a failed run also resumes automatically within the same run, with no input needed.
- **Incremental mode** (`incrementalMode`) is for recurring runs over the same search. Each listing is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` (was previously marked expired and is back), or `EXPIRED` (only after a run that scanned every result page for every target with no cap and no resume in effect, so a partial run can never wrongly mark a listing as gone). `ignoreFieldsForChanges` lists fields (dotted paths for nested ones) whose changes do not mark a listing `UPDATED`; they stay in the output and `scrapedAt` is always ignored. Changing that list re-fingerprints the saved baseline in place, so it does not produce a wave of `UPDATED` rows. `stateKey` names or shares the saved baseline; leave it empty to derive one automatically from your search filters. `incrementalMode` and `resumeFromRunId` cannot both apply to a search that already has a saved incremental baseline.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. If the picker is empty, you have not authorized a connector yet.
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` builds a query from filters; `url` reads pasted links. |
| `locations` | array | `["Москва"]` | City or region names, or an address GUID pasted directly. Search mode only. |
| `dealType` | string | `sale` | `sale` or `rent`. |
| `category` | string | `living` | `living`, `commercial`, or `garage`. |
| `offerType` | string | `flat` | `flat` (secondary market) or `layout` (new building plan). |
| `rooms` | array | `[]` | Any combination of `studio`, `1`, `2`, `3`, `4+`, `5+`. |
| `minPrice` | integer | none | Minimum price in rubles. |
| `maxPrice` | integer | none | Maximum price in rubles. |
| `minArea` | integer | none | Minimum area in square meters. |
| `maxArea` | integer | none | Maximum area in square meters. |
| `minFloor` | integer | none | Minimum floor. |
| `maxFloor` | integer | none | Maximum floor. |
| `minBuildYear` | integer | none | Only buildings built in or after this year. |
| `maxBuildYear` | integer | none | Only buildings built in or before this year. |
| `minBuildingFloors` | integer | none | Only buildings with at least this many floors. |
| `maxBuildingFloors` | integer | none | Only buildings with at most this many floors. |
| `minKitchenArea` | integer | none | Minimum kitchen area in square meters. |
| `minPricePerM2` | integer | none | Minimum price per square meter, in rubles. |
| `maxPricePerM2` | integer | none | Maximum price per square meter, in rubles. |
| `maxMetroWalkMinutes` | integer | none | Only listings within this many minutes on foot of a metro station. |
| `wallType` | array | `[]` | Any combination of `brick`, `monolith`, `panel`, `block`. |
| `notFirstFloor` | boolean | `false` | Skip first floor listings. |
| `notLastFloor` | boolean | `false` | Skip top floor listings. |
| `onlyWithPhoto` | boolean | `false` | Skip listings without photos. |
| `apartments` | string | `include` | `include`, `only` (non-residential apartment units only) or `exclude`. |
| `sortBy` | string | `relevance` | `relevance`, `newest`, `updated`, `price_asc`, `price_desc`, `price_per_m2_asc`, `price_per_m2_desc`. |
| `urls` | array | one example of each supported URL shape | Domclick search or listing links (sale/rent, commercial, garage, new-building layouts, filtered, sorted, paginated, listing cards). Leave the field untouched in URL mode and the actor scrapes one example per shape. Site filters such as `sale_price__gte` and `total_area__gte` are honoured. URL mode only. |
| `fetchDetails` | boolean | `false` | Adds a market valuation estimate, nearby points of interest count, agent deal stats and the listing card's own fields: `shortAddress`, `addressGuid`, `regionGuid`, `timezone`, `timezoneOffset`, `source`, `tradeIn`, `onlineShow`, `isAgentOwnerApproved`, `discountPersonalPercent`, `priceForYear`, `pricePerM2ForYear`, `renovation`, `pessimizationExpiration`, `priceHistory`, `photoClasses`, and per-station `distanceKm`, `lineName` and `transportMinutes` inside `subways` (new building layout rows have no card data). Reads each listing's card data, so it is slower and the detail-enrichment event is billed for each listing where any of these sources returned data; a listing whose card does not load in time keeps its base fields and is not charged for enrichment. |
| `maxPages` | integer | none (unset means unlimited) | Result pages per city or URL, about 30 listings each. Leave empty to walk every result page; the item cap and end of catalogue detection still bound the run. |
| `maxListings` | integer | `20` | Overall cap across all targets. `0` means unlimited. |
| `proxy` | object | Apify Residential, country RU | Connection settings. Apify Residential with country RU is the default and the tested choice; other groups and countries are unverified. |
| `resumeFromRunId` | string | none | A previous run id or dataset id to continue a full catalogue walk across separate runs. |
| `incrementalMode` | boolean | `false` | Recurring monitoring: remembers the previous run of the same search and returns only changed listings on later runs. |
| `stateKey` | string | none (auto derived from your filters) | Only used with `incrementalMode`. Identifies the saved baseline. |
| `emitUnchanged` | boolean | `false` | Only used with `incrementalMode`. Also return, and bill, listings with no changes, marked `changeType: UNCHANGED`. |
| `emitExpired` | boolean | `false` | Only used with `incrementalMode`. Also return, and bill, a row for a listing no longer found, marked `changeType: EXPIRED`. Only fires after a complete, uncapped, non resumed scan. |
| `ignoreFieldsForChanges` | string list | none | Only used with `incrementalMode`. Field names (dotted paths for nested ones) whose changes do not mark a listing `UPDATED`; they stay in the output. `scrapedAt` is always ignored. |
| `mcpConnectors` | array | none | Optional: send a summary of each listing to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | none | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |

### Output Example

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

```json
{
  "id": "2077927661",
  "url": "https://domclick.ru/card/sale__flat__2077927661",
  "dealType": "sale",
  "offerType": "flat",
  "price": 34999000,
  "squarePrice": 466653,
  "currency": "RUB",
  "area": 75,
  "rooms": 2,
  "floor": 14,
  "totalFloors": 17,
  "buildYear": 2026,
  "address": "Москва, набережная Примерная, 1 к1",
  "latitude": 55.0000,
  "longitude": 37.0000,
  "nearestSubway": "Технопарк",
  "subwayWalkMinutes": 12,
  "complexName": "Sample Complex",
  "sellerName": "Agent Name",
  "sellerCasId": 1234567,
  "isAgency": true,
  "companyName": "Sample Company",
  "companyFiasId": "00000000-0000-0000-0000-000000000000",
  "isRosreestrApproved": true,
  "hasDiscount": true,
  "discountValue": 500000,
  "photoCount": 11,
  "photos": ["https://img.dmclk.ru/vitrina/owner/00/00/000.jpg"],
  "publishedDate": "2026-01-01T00:00:00+00:00",
  "marketPrice": 30280000,
  "minMarketPrice": 25740000,
  "maxMarketPrice": 34820000,
  "agentDealsCompleted": 31,
  "poiCount": 50,
  "shortAddress": "Москва, улица Примерная, 1",
  "timezone": "Europe/Moscow",
  "timezoneOffset": 3,
  "priceForYear": 102000000,
  "renovation": "Без ремонта",
  "query": "Москва",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan Requirement

Domclick sits behind a JavaScript connection check that a plain HTTP request cannot pass: it answers with an empty challenge page (HTTP 401) on the connection types we tested, including Russian residential. The actor therefore loads the site in a real browser, which completes the check and then reads the data. It selects Apify Residential proxy with country RU by default under Connection, the combination that cleared the check in most of our attempts. The site also rejects connections in waves, so some attempts are denied; the actor retries on a fresh connection before it gives up. Residential proxy is available starting on the Starter plan; the Free plan has no Apify proxy; the actor then tries a backup connection and says so in the log. If that also cannot load the site, the run ends as failed with a reason instead of an empty dataset. The actor prints a warning at the start of a run when the selected proxy group is not Apify Residential, because other groups and countries have not been verified and may be blocked. If the Apify proxy is switched off and no proxy URLs are given, the run stops at once with a message that says so. If the selected connection keeps being denied by the site, the actor switches to a backup connection and says so in the log; the plan notice is shown only when the proxy connection itself is refused for the account. A run that could not read any results page ends as failed with a reason instead of an empty success.

### FAQ

#### How much does it cost?

Three events are billed, and the **Pricing** tab shows the current rate of each: a **result** for every listing pushed to the dataset (including the minimal record a pasted listing card link produces); a **detail-enrichment** for every listing that was actually enriched (when **Fetch extra details** is on, and for a pasted listing card link that returns any extra-detail data), never for a listing whose card did not load; and a **run start** event once per run. In incremental mode unchanged listings are neither pushed nor billed unless `emitUnchanged` is on. Use **Max listings** and **Max pages** to cap the cost of any run.

#### Is it legal to scrape Domclick?

This actor collects only publicly available property listing data. You are responsible for how you use it: follow Domclick's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Property facts such as price and area are generally facts, but photos and descriptions may be subject to third party rights.

#### Can I get only new or changed listings on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new, updated, reappeared, and, if enabled, expired listings, and unchanged ones are not billed by default.

#### Why does pasting a single listing link return fewer fields than a search?

The search feed has no lookup by listing id. A pasted search link walks results like search mode and returns full listings, but a pasted individual listing card link only returns the listing id, url, and the extra-detail fields (market valuation estimate and card fields such as the short address, timezone and price for a year) when available. To get the full field set for a property, search for it by city and filters instead.

#### Why did my run fail instead of returning an empty dataset?

If every request is rejected, the run stops with a clear message so "no listings found" is never confused with "nothing could be read". The first request of a run also needs to clear a one time connection check, which can take up to about 75 seconds; give a run at least 5 minutes in Input > Run options. If the run is close to running out of time, it stops with an explanatory message instead of being cut off silently. A search that genuinely has no matches still finishes successfully with zero rows.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more real estate data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🏠 <a href="https://apify.com/abotapi/cian-ru-scraper"><b>Cian RU</b></a><br>Collect property listings from Cian.ru by search filters or direct URLs. Returns...</td><td>🏷️ <a href="https://apify.com/abotapi/avito-ru-scraper"><b>Avito.ru Scraper</b></a><br>Scrape structured listings from Avito.ru by region, category, filters, or direct URL...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/immoscout24-scraper"><b>ImmobilienScout24.de Scraper</b></a><br>Extract property listings from immobilienscout24.de, Germany's #1 real estate platform...</td><td>💼 <a href="https://apify.com/abotapi/hh-ru-jobs-scraper"><b>HH.ru Jobs Scraper</b></a><br>Scrape HH.ru job listings with 50+ structured fields. Search by filters or URLs and...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/commercialguru-sg-scraper"><b>CommercialGuru SG Property Listings &amp; Agent Contacts Scraper</b></a><br>Scrape commercialguru.com.sg Singapore listings at scale. Extract prices, PSF, floor...</td><td>🏠 <a href="https://apify.com/abotapi/zonaprop-scraper"><b>Zonaprop Argentina</b></a><br>Scrape Zonaprop.com.ar property listings across Argentina. Extract 140+ fields including...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/domclick-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

Pick how to start: build a search from filters, or paste Domclick URLs.

## `locations` (type: `array`):

City or region names to search, for example "Москва", "Санкт-Петербург", "Сочи". Each name is resolved automatically. You can also paste an address GUID directly. Only applies in Search mode.

## `dealType` (type: `string`):

Sale or rent.

## `category` (type: `string`):

Property category.

## `offerType` (type: `string`):

Flat (secondary market) or layout (new building plan).

## `rooms` (type: `array`):

Filter by number of rooms. Choose any combination. 4 or more includes five and above; 5 or more means five and above only.

## `minPrice` (type: `integer`):

Minimum price in rubles.

## `maxPrice` (type: `integer`):

Maximum price in rubles.

## `minArea` (type: `integer`):

Minimum total area in square meters.

## `maxArea` (type: `integer`):

Maximum total area in square meters.

## `minFloor` (type: `integer`):

Minimum floor.

## `maxFloor` (type: `integer`):

Maximum floor.

## `minBuildYear` (type: `integer`):

Only listings in buildings built in or after this year, for example 2015.

## `maxBuildYear` (type: `integer`):

Only listings in buildings built in or before this year, for example 1990.

## `minBuildingFloors` (type: `integer`):

Only listings in buildings with at least this many floors.

## `maxBuildingFloors` (type: `integer`):

Only listings in buildings with at most this many floors.

## `minKitchenArea` (type: `integer`):

Minimum kitchen area in square metres.

## `minPricePerM2` (type: `integer`):

Minimum price per square metre in rubles.

## `maxPricePerM2` (type: `integer`):

Maximum price per square metre in rubles.

## `maxMetroWalkMinutes` (type: `integer`):

Only listings within this many minutes on foot of a metro station.

## `wallType` (type: `array`):

Filter by building wall material. Choose any combination; leave empty for all.

## `notFirstFloor` (type: `boolean`):

Skip listings on the first floor.

## `notLastFloor` (type: `boolean`):

Skip listings on the top floor of the building.

## `onlyWithPhoto` (type: `boolean`):

Skip listings that have no photos.

## `apartments` (type: `string`):

The site lists legally non-residential apartment units next to ordinary flats. Include both, show apartments only, or leave them out.

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

Result ordering.

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

Paste Domclick search links (domclick.ru/search?...), including filtered, sorted and paged links (offset=N or page=N start at that page), or listing links (domclick.ru/card/...). Multi-URL supported. Filter fields above are ignored in URL mode. Only applies in URL mode.

## `fetchDetails` (type: `boolean`):

Adds a market valuation estimate, nearby points of interest count, and agent deal stats to each listing. This loads each listing's full card page, so it is significantly slower and bills a per-listing surcharge. Best-effort: a listing whose card does not load in time keeps its base fields and is not charged for enrichment.

## `maxPages` (type: `integer`):

How many result pages (about 30 listings each) to walk per city or URL. Leave empty to walk every result page (the item cap and end-of-catalogue detection still bound the run).

## `maxListings` (type: `integer`):

Overall cap across all targets. 0 means unlimited.

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

Apify Residential with country RU is the default and the connection tested for this site (Starter plan or higher). The site rejects some connections in waves, so the actor retries on a fresh exit; other proxy groups and countries have not been verified.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a full-catalogue walk across separate runs. Listings already collected there (matched by listing id) are skipped, so this run only saves the new ones. Leave empty for a normal fresh run. See also Incremental mode below.

## `incrementalMode` (type: `boolean`):

For scheduled/recurring runs against the SAME search: remembers what this actor saw last time and only returns NEW, UPDATED, or (if enabled below) EXPIRED listings on later runs, instead of the full result set every time. Off by default so a one-off run behaves exactly as before. See also resumeFromRunId above, which continues one specific interrupted run instead.

## `stateKey` (type: `string`):

Only used when Incremental mode is on. Identifies which saved baseline this run compares against. Leave empty to derive it automatically from your search filters (so two different searches never share a baseline); set it manually to reuse or separate a baseline explicitly.

## `emitUnchanged` (type: `boolean`):

Only used when Incremental mode is on. By default, listings with no changes since the last run are skipped and not returned or billed. Turn this on to also return them (marked changeType: UNCHANGED) — this returns and bills every listing every run, not just the changes.

## `emitExpired` (type: `boolean`):

Only used when Incremental mode is on. Turn this on to also return a row for a previously-seen listing that is no longer found (marked changeType: EXPIRED) — this returns and bills an extra row per removed listing. Only fires after a run that scans every result page with no page/item cap and no resume in effect; otherwise it is safely skipped so a partial run never wrongly marks a listing as gone.

## `ignoreFieldsForChanges` (type: `array`):

Only used when Incremental mode is on. Field names (for example marketPrice) whose changes should NOT mark a listing as UPDATED. Use dotted paths for nested fields. The fields stay in the output; they just stop triggering updates. Always ignored: scrapedAt (changes on every scrape). The description, photos, subways, sellerRaw and seoRaw fields are never compared.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "Москва"
  ],
  "dealType": "sale",
  "category": "living",
  "offerType": "flat",
  "rooms": [],
  "wallType": [],
  "notFirstFloor": false,
  "notLastFloor": false,
  "onlyWithPhoto": false,
  "apartments": "include",
  "sortBy": "relevance",
  "urls": [
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&offset=30",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&page=3",
    "https://domclick.ru/search?deal_type=rent&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&rooms=1&sort=price&sort_dir=asc",
    "https://domclick.ru/search?deal_type=sale&category=commercial&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=garage&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=layout&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sale_price__gte=5000000&sale_price__lte=9000000&total_area__gte=40&floor__gte=3",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sort=price&sort_dir=desc",
    "https://domclick.ru/card/sale__flat__2068743510"
  ],
  "fetchDetails": false,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `changes` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "locations": [
        "Москва"
    ],
    "urls": [
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&offset=30",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&page=3",
        "https://domclick.ru/search?deal_type=rent&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&rooms=1&sort=price&sort_dir=asc",
        "https://domclick.ru/search?deal_type=sale&category=commercial&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=garage&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=layout&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sale_price__gte=5000000&sale_price__lte=9000000&total_area__gte=40&floor__gte=3",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sort=price&sort_dir=desc",
        "https://domclick.ru/card/sale__flat__2068743510"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    },
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/domclick-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 = {
    "mode": "search",
    "locations": ["Москва"],
    "urls": [
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&offset=30",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&page=3",
        "https://domclick.ru/search?deal_type=rent&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&rooms=1&sort=price&sort_dir=asc",
        "https://domclick.ru/search?deal_type=sale&category=commercial&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=garage&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=layout&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sale_price__gte=5000000&sale_price__lte=9000000&total_area__gte=40&floor__gte=3",
        "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sort=price&sort_dir=desc",
        "https://domclick.ru/card/sale__flat__2068743510",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/domclick-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 '{
  "mode": "search",
  "locations": [
    "Москва"
  ],
  "urls": [
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&offset=30",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&page=3",
    "https://domclick.ru/search?deal_type=rent&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&rooms=1&sort=price&sort_dir=asc",
    "https://domclick.ru/search?deal_type=sale&category=commercial&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=garage&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=layout&address=1d1463ae-c80f-4d19-9331-a1b68a85b553",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sale_price__gte=5000000&sale_price__lte=9000000&total_area__gte=40&floor__gte=3",
    "https://domclick.ru/search?deal_type=sale&category=living&offer_type=flat&address=1d1463ae-c80f-4d19-9331-a1b68a85b553&sort=price&sort_dir=desc",
    "https://domclick.ru/card/sale__flat__2068743510"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  },
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/domclick-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/domclick-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/aWBJ9N7pt10DbvtXH/builds/qJhhXDCfsWZgORKmV/openapi.json