# CIAN Property Listings Extractor (`kawsar/cian-property-listings-extractor`) Actor

CIAN property listings extractor that turns any CIAN search URL into structured data with prices, area, floor, address, metro, coordinates, photos and agency contacts, so you can research the market and track listings without copying anything by hand.

- **URL**: https://apify.com/kawsar/cian-property-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/actors/running/actors-in-store.md#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

## CIAN Property Listings Extractor

Extract real estate listings from CIAN (cian.ru) at scale, without copying anything by hand. Paste any CIAN search or category URL and this actor returns clean, structured data for apartments, flats, rooms, and new builds across Russia, ready for a spreadsheet, database, or BI tool.

CIAN is one of the largest property portals in Russia, with millions of active listings. This actor reads a search you already set up on the site, follows the pagination automatically, and turns every result into a row of typed data you can download as JSON, CSV, or Excel.

### Why use this actor

- **Zero manual work.** Filter on CIAN, copy the URL, run the actor. No selectors to configure.
- **Complete records.** Price, area, floor, address, coordinates, metro, developer, photos, and contacts in one row.
- **Automatic pagination.** The actor walks through result pages until it hits your limit or the end of the search.
- **Clean, typed output.** Numbers come back as numbers, areas as floats, photos as an array of URLs.
- **Multiple searches per run.** Pass several URLs to cover different cities, deal types, or price bands at once.
- **Export anywhere.** JSON, CSV, Excel, HTML, or the Apify API and dataset webhooks.

### What you can collect

| Category | Fields |
| --- | --- |
| Identity | `id`, `url` |
| Deal | `dealType`, `offerType`, `flatType` |
| Layout | `roomsCount`, `totalArea`, `livingArea`, `kitchenArea`, `floorNumber`, `floorsCount`, `isApartments` |
| Building | `buildYear`, `materialType`, `complexName`, `developerName` |
| Price | `price`, `priceRur`, `currency`, `formattedPrice`, `mortgageAllowed` |
| Location | `address`, `latitude`, `longitude`, `metroStation`, `metroTimeMinutes`, `metroTransport` |
| Media | `photos`, `photosCount` |
| Seller | `phones`, `agencyName`, `isAgent`, `isHomeowner` |
| Meta | `listingDescription`, `publishedDate`, `addedLabel`, `scrapedAt` |

### Input

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `searchUrls` | array of strings | Yes | `https://www.cian.ru/kupit-kvartiru/` | One or more CIAN search or category URLs to extract. |
| `maxItems` | integer | No | `20` | Maximum listings per run across all URLs (up to 1000). |
| `requestTimeoutSecs` | integer | No | `30` | Per-request timeout in seconds (5 to 120). |

#### Example input

```json
{
    "searchUrls": [
        "https://www.cian.ru/kupit-kvartiru/",
        "https://www.cian.ru/snyat-kvartiru/"
    ],
    "maxItems": 50,
    "requestTimeoutSecs": 30
}
```

### Output

Each listing becomes one dataset item. Records export to JSON, CSV, Excel, or HTML, and are available through the Apify API.

```json
{
    "id": 332401547,
    "url": "https://www.cian.ru/sale/flat/332401547/",
    "dealType": "sale",
    "offerType": "flat",
    "flatType": "rooms",
    "roomsCount": 4,
    "totalArea": 494.2,
    "livingArea": 443.0,
    "kitchenArea": null,
    "floorNumber": 3,
    "floorsCount": 4,
    "isApartments": false,
    "buildYear": null,
    "materialType": "monolith",
    "price": 1863272376,
    "priceRur": 1863272376,
    "currency": "rur",
    "formattedPrice": "1 863 272 376 ₽",
    "mortgageAllowed": null,
    "address": "Москва, ЦАО, р-н Пресненский, Трехпрудный переулок, 9С2",
    "latitude": 55.765043,
    "longitude": 37.596552,
    "metroStation": "Пушкинская",
    "metroTimeMinutes": 7,
    "metroTransport": "walk",
    "complexName": "ЖК «Клубный дом Левенсон»",
    "developerName": "VESPER",
    "photos": [
        "https://images.cdn-cian.ru/images/2933422190-1.jpg"
    ],
    "photosCount": 31,
    "phones": ["+79339377442"],
    "agencyName": "VESPER",
    "isAgent": true,
    "isHomeowner": null,
    "listingDescription": "Двухуровневая квартира площадью 495,9 м² ...",
    "publishedDate": "2026-07-28T15:10:11.263",
    "addedLabel": "21 авг, 16:13",
    "scrapedAt": "2026-09-07T12:14:22Z"
}
```

#### Field reference

| Field | Type | Description |
| --- | --- | --- |
| `id` | number | CIAN listing ID. |
| `url` | string | Direct link to the listing page. |
| `dealType` | string | `sale` or `rent`. |
| `offerType` | string | Property type, such as `flat`. |
| `flatType` | string | Layout type, such as `rooms` or `studio`. |
| `roomsCount` | number | Number of rooms. |
| `totalArea` | number | Total area in square meters. |
| `livingArea` | number | Living area in square meters. |
| `kitchenArea` | number | Kitchen area in square meters. |
| `floorNumber` | number | Floor the unit is on. |
| `floorsCount` | number | Total floors in the building. |
| `isApartments` | boolean | Whether the unit is classed as apartments (apartamenty). |
| `buildYear` | number | Year the building was completed. |
| `materialType` | string | Construction material, such as `monolith` or `brick`. |
| `price` | number | Listing price in the listing currency. |
| `priceRur` | number | Price converted to rubles. |
| `currency` | string | Currency code, usually `rur`. |
| `formattedPrice` | string | Human-readable price with separators and symbol. |
| `mortgageAllowed` | boolean | Whether a mortgage is accepted. |
| `address` | string | Full address as shown on CIAN. |
| `latitude` | number | Latitude of the property. |
| `longitude` | number | Longitude of the property. |
| `metroStation` | string | Nearest metro station. |
| `metroTimeMinutes` | number | Time to that station. |
| `metroTransport` | string | `walk` or `transport`. |
| `complexName` | string | Residential complex (ZhK) name. |
| `developerName` | string | Developer or builder name. |
| `photos` | array | Full-size photo URLs. |
| `photosCount` | number | Number of photos. |
| `phones` | array | Contact phone numbers in E.164 form. |
| `agencyName` | string | Agency or company name. |
| `isAgent` | boolean | Whether the seller is an agent. |
| `isHomeowner` | boolean | Whether the seller is the owner. |
| `listingDescription` | string | Full listing text. |
| `publishedDate` | string | ISO publication timestamp. |
| `addedLabel` | string | Human-readable "added" label from CIAN. |
| `scrapedAt` | string | ISO timestamp of extraction. |

### How to get a CIAN search URL

1. Open [cian.ru](https://www.cian.ru/) and choose a deal type, such as buy or rent.
2. Apply the filters you want: rooms, price range, district, metro line, property type.
3. Wait for the results to load, then copy the URL from the browser address bar.
4. Paste it into `searchUrls`.

Add several URLs to pull different cities or filters in a single run. A few examples:

- Buy apartments: `https://www.cian.ru/kupit-kvartiru/`
- Rent apartments: `https://www.cian.ru/snyat-kvartiru/`
- New builds: `https://www.cian.ru/kupit-kvartiru-v-novostrojke/`

### Common use cases

- **Price monitoring.** Track asking prices by district, room count, or complex over time.
- **Market research.** Measure supply, average price per square meter, and inventory across neighborhoods.
- **Lead generation.** Collect agency and owner listings that match a target profile.
- **Competitor tracking.** Watch what specific agencies or developers list and at what price.
- **Investment analysis.** Compare yields and pricing between areas and building types.
- **Data enrichment.** Feed listing data into CRMs, dashboards, or valuation models.

### Running the actor

**Apify Console.** Open the actor, paste your search URLs, set `maxItems`, and click Start. Download results from the Storage tab.

**Apify API.** Start a run and read the dataset:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "searchUrls": ["https://www.cian.ru/kupit-kvartiru/"], "maxItems": 50 }'
```

**Scheduling.** Use Apify Schedules to run the actor on an interval and keep a rolling dataset of new listings.

### Tips and limits

- Start with a small `maxItems` while you test filters, then raise it for a full pull.
- CIAN returns roughly 28 listings per results page. The actor paginates automatically until it reaches your limit or the last page.
- Large runs take longer and use more compute, so scope your search on CIAN before extracting.
- The actor only reads public listing pages. It does not log in and does not attempt private data.

### FAQ

**Which CIAN URLs work?**
Any public search or category URL on `cian.ru`, including filtered searches with query parameters.

**Can I scrape rentals and new builds too?**
Yes. Use the matching CIAN category URL (rent, new builds, and so on). The output structure stays the same.

**How many listings can I get per run?**
Up to 1000 per run via `maxItems`. Split larger jobs across scheduled runs or multiple search URLs.

**What format is the output?**
Structured dataset items you can export as JSON, CSV, Excel, or HTML, or read through the Apify API.

### Support

If a field looks off for a specific search or you need an extra field, open an issue on the actor page with the search URL you used so it can be reproduced.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more CIAN search or category URLs to extract listings from. Open CIAN, apply your filters (deal type, rooms, price, location), then paste the resulting search URL here.

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

Maximum number of listings to extract per run across all search URLs.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.cian.ru/kupit-kvartiru/",
    "https://www.cian.ru/snyat-kvartiru/"
  ],
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `properties` (type: `string`):

Extracted CIAN property listings dataset.

# 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 = {
    "searchUrls": [
        "https://www.cian.ru/kupit-kvartiru/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/cian-property-listings-extractor").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 = { "searchUrls": ["https://www.cian.ru/kupit-kvartiru/"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/cian-property-listings-extractor").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 '{
  "searchUrls": [
    "https://www.cian.ru/kupit-kvartiru/"
  ]
}' |
apify call kawsar/cian-property-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/cian-property-listings-extractor"
        }
    }
}
```

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/9Ggo1eHcTOgJJopAw/builds/0M9qEZpU9VG7Vdcha/openapi.json