# SS.lv Scraper - Latvia Property Listings & Prices (`sian.agency/ss-property-scraper`) Actor

Scrape SS.lv property listings across Latvia: asking price or monthly rent, rooms, area, floor, series, photos, coordinates and full advert text. Latvia's largest classifieds portal, in Latvian.

- **URL**: https://apify.com/sian.agency/ss-property-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.54 / 1,000 property searches

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

## SS.lv Scraper - Latvia Property Listings & Prices 🚀

[![Store SIÁN Agency](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store Aruodas Scraper](https://img.shields.io/badge/Store-Aruodas%20Scraper-1AE392)](https://apify.com/sian.agency/aruodas-property-scraper?fpr=sian) [![Store Imot.bg Scraper](https://img.shields.io/badge/Store-Imot.bg%20Scraper-1AE392)](https://apify.com/sian.agency/imot-property-scraper?fpr=sian) [![Store Hemnet Scraper](https://img.shields.io/badge/Store-Hemnet%20Scraper-1AE392)](https://apify.com/sian.agency/hemnet-property-scraper?fpr=sian)

#### 🎉 Every SS.lv property advert, in Latvian, sale and rent separated for you

##### For analysts pricing the Latvian market, agencies sourcing stock, and anyone tired of scrolling Rīga's 150 pages by hand

### 🔎 What is the SS.lv Latvia Property Scraper — and when should you use it?

The **SS.lv Latvia Property Scraper** turns public SS.lv property adverts from anywhere in Latvia into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** Latvian sale and rental adverts as rows: asking price or monthly rent, rooms, area, floor, building height, the Soviet-era build series, district and street, a photo and the advert URL. SS.lv mixes sale and rental adverts in one feed and this Actor reads the deal type off the price text, so a rents-only run works on the first press of Start. Switch on full details and each row also carries the untruncated advert text, the complete photo set, the attribute table (house type, comforts), the publication date and the advert's own map coordinates.

**Use something else when:** the property is not in Latvia. Use [Aruodas Scraper](https://apify.com/sian.agency/aruodas-property-scraper?fpr=sian) for Lithuania's property market on the country's #1 portal, one border away, with the same row shape. Use [Imot.bg Scraper](https://apify.com/sian.agency/imot-property-scraper?fpr=sian) for Bulgaria's longest-running classifieds portal, sale and rental, with price per square metre already computed. Use [Hemnet Scraper](https://apify.com/sian.agency/hemnet-property-scraper?fpr=sian) for Sweden's market leader — Nordic asking prices, fee and monthly cost in one row. This actor covers the six city-first property sections of ss.lv — flats, houses and summer residences, farmsteads, offices, land and forest — across every top-level area the site indexes, plus its abroad-residence sections. The Telpas (premises) section uses a different address shape and is out of scope in this version, though its adverts remain reachable by URL through Property Detail, and so is sold history, because the site publishes only what is currently on the market.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/ss-property-scraper

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want property adverts and asking prices from SS.lv using the Apify Actor `sian.agency/ss-property-scraper`.

Use it when I need: Latvian sale and rental adverts as rows: asking price or monthly rent, rooms, area, floor, building height, the Soviet-era build series, district and street, a photo and the advert URL. SS.lv mixes sale and rental adverts in one feed and this Actor reads the deal type off the price text, so a rents-only run works on the first press of Start. Switch on full details and each row also carries the untruncated advert text, the complete photo set, the attribute table (house type, comforts), the publication date and the advert's own map coordinates.

Don't use it when: the property is not in Latvia — use aruodas-property-scraper or imot-property-scraper or hemnet-property-scraper instead.

How to call it: pick a `section` (flats is the deep one) and give `locations` a list of SS.lv areas (`riga`, `jurmala`, `riga-region` — the picker lists all 31). Narrow with `dealType` (`sale`, `rent` or `all`), `minPrice`, `maxPrice`, `minArea`, `maxArea` or `minRooms` — anything a filter excludes is never saved and never billed. `maxResults` is the budget for the whole run and is shared across the areas you picked, so three areas each get roughly a third rather than the first taking everything. `includeDetails` opens each advert for its full text, every photo and the map coordinates, for an extra charge per listing. To follow a single district such as Centrs or Imanta, paste its ss.lv address into `searchUrls`; to expand adverts you already have, set `operation` to `detail` and pass `listingUrls`.

Start with this input:
{
  "operation": "search",
  "section": "flats",
  "locations": [
    "riga"
  ],
  "dealType": "sale",
  "maxResults": 200
}

Ask me which parts of Latvia to cover, whether the run should keep sale adverts, rentals or both, and whether the full advert text and map coordinates are worth the extra per-listing charge, then run the Actor and summarise the results as a table, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Pull every two-bedroom flat for sale in Rīga under €200,000 and rank the districts by median price per square metre.*
- *Give me this week's new rental adverts in Jūrmala with the monthly price and a photo for each.*
- *Compare asking prices per square metre across Rīga, Jūrmala and the Rīga commuter belt in one table.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/ss-property-scraper.md](https://apify.com/sian.agency/ss-property-scraper.md).

### 📋 Overview

**SS.lv is where Latvia's property market actually happens.** The country's #1 site overall at 5.4 million visits a month — ahead of every dedicated property portal — it is the default place a Latvian seller posts a flat, a house or a plot, from Rīga agency chains down to owners posting a phone number. This Actor reads it the way the site publishes it and hands you the rows.

**Why professionals choose us:**

- ✅ **Sale and rent in one feed, separated for you**: SS.lv mixes the two and writes the difference into the price (€/mēn. is a monthly rent); this Actor reads that and stamps every row, so a rents-only run works the first time
- ⚡ **30 listings per request**: a 1,000-listing sweep of Rīga is 34 requests and finishes in a couple of minutes
- 🎯 **Latvian that survives the trip**: UTF-8 end to end, so Rīga, Ķengarags and Šķirotava arrive readable in JSON, CSV and Excel alike
- 💰 **$4.00 per 1,000 listings**: 20% under the only SS.lv Actor with traction, with a richer row
- 📍 **Coordinates on request**: full details lifts each advert's map coordinates from the advert's own map link — no geocoder needed
- 🧱 **Series and house type**: the Soviet-era build series (Lt proj., 602. series) SS.lv prints on the card comes through on every flats row

### ✨ Features

- 🔍 **Two operations in one Actor**: search SS.lv's listing pages, or expand specific adverts by URL
- 🇱🇻 **Every area SS.lv indexes**: Rīga, Jūrmala, Rīgas rajons and all 22 regional areas, picked from a list rather than typed
- 🏘️ **Six property sections**: flats, houses and summer residences, farmsteads, offices, land and forest
- 🤝 **Deal type on every row**: sale or monthly rent, read from the price text the site itself prints
- 🎚️ **Filters that cost nothing**: price band, area, rooms, deal type — excluded adverts are never saved and never charged
- 📄 **Full details as a paid add-on**: untruncated advert text, every photo, the attribute table, the publication date and the map coordinates
- 🔗 **Paste a URL instead**: any SS.lv listing address works, including the 49 district pages under Rīga
- 📊 **Run report included**: a copy-ready list of advert links, a median price and the itemised charge statement in every run

### 🎬 Quick Start

Pick an area, press Start. The defaults return Rīga flat listings, so a run with no configuration at all still gives you real data. Everything below is optional narrowing.

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~ss-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation":"search","section":"flats","locations":["riga"],"maxResults":100}'
```

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your section and areas

Pick the property section (flats is the deepest) and one or more areas from the list. Rīga and Jūrmala exist for most sections; a pair the site does not publish is rejected before anything runs.

#### Step 2: Narrow if you want to

Set the deal type to sale or rent, add price, area or room bounds. Nothing a filter excludes is saved or charged.

#### Step 3: Press Start, then export

Watch the run log count the pages. When it finishes, download JSON, CSV or Excel from the dataset, or open the HTML report for a summary with the advert links already collected.

**That's it! In under two minutes, you'll have:**

- Every matching listing with price, deal type, rooms, area, floor and series
- A copy-ready list of advert links
- With full details on: the complete advert text, every photo and the map coordinates

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `operation` | string | No | `search` (default) or `detail` |
| `section` | string | No | `flats` (default), `homes-summer-residences`, `farms-estates`, `offices`, `plots-and-lands`, `wood` |
| `locations` | array | No | SS.lv areas, e.g. `riga`, `jurmala`, `riga-region` — defaults to Rīga |
| `maxResults` | integer | No | Whole-run listing budget, default 100, shared across the areas |
| `dealType` | string | No | `all` (default), `sale` or `rent` |
| `minPrice` / `maxPrice` | integer | No | Price bounds in euros; 0 means no bound |
| `minArea` / `maxArea` | integer | No | Area bounds in square metres; 0 means no bound |
| `minRooms` | integer | No | Minimum room count; 0 means no minimum |
| `includeDetails` | boolean | No | Open each advert for the full text, all photos and the coordinates |
| `searchUrls` | array | No | SS.lv listing addresses, including district pages |
| `listingUrls` | array | No | SS.lv advert addresses, for the `detail` operation |

**Example:**

```json
{
  "operation": "search",
  "section": "flats",
  "locations": ["riga", "jurmala"],
  "dealType": "sale",
  "maxPrice": 200000,
  "maxResults": 500
}
```

**Rental monitoring on a schedule:**

```json
{
  "operation": "search",
  "section": "flats",
  "locations": ["riga"],
  "dealType": "rent",
  "maxResults": 300
}
```

**Expand specific adverts:**

```json
{
  "operation": "detail",
  "listingUrls": [
    { "url": "https://www.ss.lv/msg/lv/real-estate/flats/riga/centre/adbgb.html" }
  ]
}
```

### 📤 Output

Results are saved to the Apify dataset with **30+ fields**, including:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | SS.lv advert id (the tr\_ number on the listing table) |
| `propertyTitle` | string | The advert headline, in the language its author wrote it |
| `url` | string | Canonical advert address |
| `price` | number | Asking price, or monthly rent for a rental |
| `currency` | string | `EUR` on every priced row |
| `priceText` | string | The price exactly as the site shows it |
| `pricePerSqm` | number | Price per square metre, from the advert page (`includeDetails`) |
| `dealType` | string | `sale` or `rent`, read from the price text |
| `rooms` / `area` | number | Rooms and area in m², as the card shows them |
| `floor` / `totalFloors` | number | Floor number and floors in the building |
| `series` | string | The build series SS.lv prints for flats (Lt proj., 602., …) |
| `houseType` / `comforts` | string | Attribute-table entries (`includeDetails`) |
| `district` / `street` / `city` | string | Where the property is |
| `lat` / `lon` | number | Map coordinates from the advert's own map link (`includeDetails`) |
| `photos` / `photoCount` | array, number | Photo URLs and how many there are (`includeDetails`) |
| `descriptionText` | string | The seller's full advert text (`includeDetails`) |
| `publishedAt` | string | When the advert was posted (`includeDetails`) |
| `searchedLocation` / `searchUrl` | string | Which run and address produced the row |

**Example:**

```json
{
  "listingId": "58024258",
  "url": "https://www.ss.lv/msg/lv/real-estate/flats/riga/centre/adbgb.html",
  "propertyTitle": "Jūsu uzmanībai stilīgs 3 istabu dzīvoklis pilsētas centrā pēc kapitālā remonta.",
  "district": "centrs",
  "street": "Lugažu 6",
  "dealType": "sale",
  "price": 97000,
  "currency": "EUR",
  "priceText": "97 000 € (1 564.52 €/m²)",
  "pricePerSqm": 1564.52,
  "rooms": 3,
  "area": 62,
  "floor": 4,
  "totalFloors": 5,
  "series": "LT proj.",
  "houseType": "Paneļu",
  "photoCount": 8,
  "lat": 56.974974,
  "lon": 24.109142,
  "publishedAt": "2026-09-07T01:27:00"
}
```

### 💼 Use Cases & Examples

#### 1. Latvian asking-price index

**A property analyst measuring what a district really asks per square metre.**

**Input:** Rīga plus Jūrmala and the commuter belt, a high `maxResults`
**Output:** every listing with price, area, rooms and floor, grouped by district in the export
**Use:** build the district index that SS.lv's own page averages cannot give you

#### 2. Rental market monitoring

**A property manager keeping a rent roll current.**

**Input:** `dealType: "rent"`, your areas, a schedule
**Output:** only the rental stock, priced in € per month, each row labelled `rent`
**Use:** the same run every morning, with nothing else mixed in

#### 3. New-listing alerts

**A buying agent who needs to see today's stock today.**

**Input:** your saved areas on a daily schedule
**Output:** the newest adverts first — SS.lv serves its feeds newest-first
**Use:** keep the advert IDs you have seen; anything new in the export appeared since yesterday

#### 4. Buyer shortlists with coordinates

**A relocation service building a map for a client.**

**Input:** `includeDetails: true`, a price band, a room minimum
**Output:** rows carrying the advert's own latitude and longitude, every photo and the full text
**Use:** feed the rows straight into a map — no geocoding step at all

#### 5. District-level comparisons

**An analyst comparing Centrs against Imanta.**

**Input:** district addresses pasted into `searchUrls`, one per line
**Output:** one sweep per district, same row shape, in one run
**Use:** per-district price bands without building anything yourself

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/ss-property-scraper').call({
  operation: 'search',
  section: 'flats',
  locations: ['riga'],
  dealType: 'sale',
  maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/ss-property-scraper').call(
    run_input={
        'operation': 'search',
        'section': 'flats',
        'locations': ['jurmala'],
        'dealType': 'rent',
        'maxResults': 200,
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['propertyTitle'], item['price'], item['dealType'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~ss-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation":"search","section":"flats","locations":["riga"],"dealType":"rent","maxResults":150}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: a daily schedule, or a webhook from your own system
2. **HTTP Request**: call the Actor's run-sync endpoint with your saved input
3. **Process**: split the rows on `dealType`, or group by `district`
4. **Action**: append to a sheet, upsert into your CRM, or post the new adverts to Slack

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 listings** per run, with every field and every filter available
- No credit card required
- Enough to check the data before you commit to a sweep

#### PAID Tier (Production Ready)

- **Unlimited** listings per run, bounded only by your `maxResults` budget
- Pay-per-result: charged per listing saved, never for an advert your filters excluded
- Full details available as a per-listing add-on, only when you switch it on

💰 **$4.00 per 1,000 listings**, which is 20% below the leading SS.lv Actor on the Store. Deal type, series, district, street and the full attribute table all sit on the same row.

🔗 [View current pricing](https://apify.com/sian.agency/ss-property-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: How many listings can I get per run?**
A: FREE tier: 25 per run. PAID tier: as many as you budget for. Rīga's flat feed alone runs to 150+ pages of 30, so the practical limit is your `maxResults`.

**Q: Will the Latvian text come through correctly?**
A: Yes. SS.lv is published in UTF-8 end to end, so every diacritic arrives intact in the dataset, in every export and in the HTML report. Russian-language adverts appear exactly as the site mixes them in.

**Q: How do sale and rental adverts work here?**
A: SS.lv keeps them in one feed, and the price text tells you which is which: a rent reads "€/mēn." (per month) while a sale reads a plain euro figure. Every row carries a `dealType`, and the `dealType` filter keeps only the kind you want.

**Q: What is the difference between a listing row and full details?**
A: A listing row carries everything on the card: price, deal type, rooms, area, floor, series, district, street and a photo. Full details opens the advert itself and adds the untruncated text, every photo, the house type and comforts, the publication date and the map coordinates.

**Q: Can I follow a single Rīga district?**
A: Yes, through Search URLs. Open the district page on ss.lv — for example https://www.ss.lv/lv/real-estate/flats/riga/centre/ — and paste the address. The Areas list covers cities and regions; a pasted address reaches anything the site publishes.

**Q: What happens to an advert that has been withdrawn?**
A: SS.lv answers a dead advert with a normal-looking page that has nothing in it. The Actor recognises that, writes a row saying the listing could not be found, and does not charge you for it.

**Q: Does it cover SS.com or the Russian version of the site?**
A: SS.com is the same portal under a different name, and the Russian pages are the same adverts at /ru/ addresses. This Actor reads the Latvian site — where both languages appear in the feed — and reports each advert in the language its author wrote it in.

**Q: What output formats are available?**
A: JSON, CSV, Excel and XML. Export straight from the Apify dataset, or read them over the API.

### 🐛 Troubleshooting

**A run returns fewer listings than expected**

- The budget is shared across the areas you picked — three areas each get roughly a third of `maxResults`
- Raise `maxResults`, or run the areas one at a time if you need the full depth of each

**A filter returned nothing**

- Check the combination exists: price bounds exclude adverts where SS.lv publishes no number, and a tight bound on a thin area can empty the result
- Nothing filtered out is charged, so an empty run costs you the run-start fee and nothing else

**An area name was rejected**

- The picker lists what SS.lv actually indexes; Rīga has no Forest or Farmsteads section, and the abroad areas belong to the residence sections
- A single district is reached by pasting its ss.lv address into Search URLs instead

**A listing URL comes back as not found**

- The advert has been sold, rented or withdrawn; SS.lv keeps the address alive but empties the page
- Re-run the search to pick up what is live today

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

SS.lv and SS.com are trademarks of SIA SS. This Actor is not affiliated with, endorsed by, or sponsored by SS.lv or SIA SS.

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue on the [Actor's issues page](https://apify.com/sian.agency/ss-property-scraper/issues)
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

Pick one per run. Property Search walks SS.lv's own listing pages for any area it indexes and returns 30 listings per page, sale adverts and monthly rents alike, exactly as the site mixes them. Property Detail takes SS.lv advert URLs and returns the full advert text, every photo, the attribute table and the map coordinates.

## `section` (type: `string`):

Which of SS.lv's property sections to read. Flats is the deep one — Rīga alone holds thousands of adverts across 49 districts. SS.lv keeps sale and rental adverts in the same feed, so both arrive in one run and the Deal type filter below decides which rows are kept.

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

Which parts of Latvia to read. Every value is SS.lv's own area, so the list is exactly what the site indexes — Rīga, Jūrmala, Rīgas rajons (the capital's commuter belt) and one entry per regions-and-town pair elsewhere. An area exists only in some sections (Rīga has no Forest or Farmsteads section), and a run naming a pair the site does not publish stops at validation, before anything is charged. A single district such as Centrs or Imanta is reached by pasting that district's SS.lv address…

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

Stop after this many listings across the whole run, not per area. One page carries 30 listings, so a run ends on the first page that crosses your limit. The budget is shared across every area you picked, so two areas each get roughly half of what you asked for rather than the first area taking it all.

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

SS.lv mixes sale and rental adverts in one feed, and the price text tells them apart (a monthly rent reads €/mēn.). Keep both, or keep only one kind. Filtered-out adverts are never saved and never charged.

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

Skip listings priced below this. 0 means no lower bound. For a rental this is the monthly price. Listings with no price at all are kept whatever you set here.

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

Skip listings priced above this. 0 means no upper bound.

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

Skip listings smaller than this. 0 means no minimum. Only listings whose card shows an area in m² can be filtered this way; land rows show their area in the same column, in hectares where the site does.

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

Skip listings larger than this. 0 means no maximum.

## `minRooms` (type: `integer`):

Skip flats with fewer rooms than this. 0 means no minimum. The rooms column exists on the Flats section; other sections show something else there and are passed through untouched.

## `includeDetails` (type: `boolean`):

Open each listing's own advert page to add the untruncated advert text, the complete photo set instead of the one thumbnail on the card, the full attribute table (house type, comforts), the publication date and the map coordinates. Costs one extra request per listing and bills the Property Detail event on top of the listing row.

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

Paste SS.lv listing addresses instead of filling the form. Build the view on ss.lv, copy the address bar, and the run reads exactly that page and pages forward from it — including district-level addresses such as https://www.ss.lv/lv/real-estate/flats/riga/centre/ that the Areas list does not reach. A page number in the address is dropped; the run starts at page one.

## `listingUrls` (type: `array`):

Used by the Property Detail operation: SS.lv advert addresses to expand, e.g. https://www.ss.lv/msg/lv/real-estate/flats/riga/centre/adbgb.html.

## Actor input object example

```json
{
  "operation": "search",
  "section": "flats",
  "locations": [
    "riga"
  ],
  "maxResults": 100,
  "dealType": "all",
  "minPrice": 0,
  "maxPrice": 0,
  "minArea": 0,
  "maxArea": 0,
  "minRooms": 0,
  "includeDetails": false,
  "searchUrls": [],
  "listingUrls": []
}
```

# Actor output Schema

## `ssLvListings` (type: `string`):

Every listing this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "search",
    "section": "flats",
    "locations": [
        "riga"
    ],
    "maxResults": 100,
    "dealType": "all",
    "minPrice": 0,
    "maxPrice": 0,
    "minArea": 0,
    "maxArea": 0,
    "minRooms": 0,
    "includeDetails": false,
    "searchUrls": [],
    "listingUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/ss-property-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 = {
    "operation": "search",
    "section": "flats",
    "locations": ["riga"],
    "maxResults": 100,
    "dealType": "all",
    "minPrice": 0,
    "maxPrice": 0,
    "minArea": 0,
    "maxArea": 0,
    "minRooms": 0,
    "includeDetails": False,
    "searchUrls": [],
    "listingUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/ss-property-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 '{
  "operation": "search",
  "section": "flats",
  "locations": [
    "riga"
  ],
  "maxResults": 100,
  "dealType": "all",
  "minPrice": 0,
  "maxPrice": 0,
  "minArea": 0,
  "maxArea": 0,
  "minRooms": 0,
  "includeDetails": false,
  "searchUrls": [],
  "listingUrls": []
}' |
apify call sian.agency/ss-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/ss-property-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/bNMj9HUfkAeuCk6gJ/builds/OPEU4ElUaVS5KPGkU/openapi.json