# Domoplius.lt Scraper — Lithuanian Real Estate (`studio-amba/domoplius-lt-scraper`) Actor

Scrape property listings from Domoplius.lt, Lithuania's #2 real estate portal (sibling to aruodas-scraper). Apartments, houses, commercial, land and garages, with price, area, rooms, GPS coordinates, seller details and photos.

- **URL**: https://apify.com/studio-amba/domoplius-lt-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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

## Domoplius.lt Scraper

Extract real estate listings from [Domoplius.lt](https://domoplius.lt), Lithuania's #2 property portal (sibling to [Aruodas.lt](https://www.aruodas.lt), LT's #1). Domoplius covers apartments, houses, commercial premises, land plots and garages, listed by agencies, brokers and private sellers.

### Why use this actor?

Domoplius.lt is the second-largest property marketplace in Lithuania, with thousands of active listings across every major city. This actor collects structured listing data — price, area, rooms, GPS coordinates, seller details, photos and building specs — without manual browsing.

Use cases include:

- **Market analysis**: Track property prices across Lithuanian cities and neighbourhoods, in parallel with aruodas-scraper for full LT coverage
- **Investment research**: Compare listings across both major Lithuanian portals
- **Relocation planning**: Find apartments or houses in a specific city or microdistrict
- **Price monitoring**: Watch price-per-m² trends for a property type over time
- **Mapping**: Plot listings on a map using the GPS latitude/longitude on every detail-fetched record
- **Lead generation**: Identify agency vs. private-seller listings for outreach

### How to scrape Domoplius.lt data

1. Go to the actor's page on the Apify Store
2. Pick a category (apartments, houses, commercial, land or garages) and a listing type (for sale or for rent) — Domoplius has no free-text search, filtering works by category instead
3. Set the maximum number of results you want
4. Leave detail fetching on for the full field set (GPS, description, photos, building details), or turn it off for a faster, thinner scan
5. Click "Start" to run the scraper
6. Download results as JSON, CSV, or Excel when complete

The actor handles Domoplius.lt's Cloudflare Turnstile protection automatically using a Lithuanian residential proxy. No login is needed.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `propertyType` | String | No | `butai` (apartments, default), `namai-kotedzai-sodai` (houses/cottages), `komercines-patalpos` (commercial), `sklypai` (land), `garazai` (garages) |
| `listingType` | String | No | `sale` (default) or `rent` |
| `maxResults` | Integer | No | Maximum listings to return (default: 100, hard cap: 5000) |
| `fetchDetails` | Boolean | No | Fetch each listing's detail page for the full field set (default: true). Off is faster but returns only search-card fields. |
| `proxyConfiguration` | Object | No | Proxy settings. Residential proxies with Lithuanian geolocation are required — configured by default. |

There is no `searchQuery` field — Domoplius.lt does not offer free-text search on this vertical, only category and listing-type filters.

### Output

Each listing produces a JSON object with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | Integer | Domoplius.lt numeric listing ID |
| `listingTitle` | String | Listing title |
| `price` | Number | Price or rent in EUR |
| `currency` | String | Always "EUR" |
| `pricePerSqm` | Number | Price divided by area |
| `area` | Number | Area in square metres |
| `rooms` | Number | Number of rooms |
| `floor` | String | Floor / total floors, e.g. "5/5" |
| `location` | String | City, microdistrict, street |
| `propertyType` | String | apartment, house, commercial, plot, or garage |
| `transactionType` | String | sale or rent |
| `imageUrl` | String | First listing photo |
| `url` | String | Full listing URL on Domoplius.lt |
| `listingDescription` | String | Full free-text description |
| `scrapedAt` | String | ISO 8601 timestamp |
| `latitude` | Number | GPS latitude (detail fetch only) |
| `longitude` | Number | GPS longitude (detail fetch only) |
| `city` | String | City name |
| `microdistrict` | String | Neighbourhood name |
| `datePosted` | String | Date posted, YYYY-MM-DD (detail fetch only) |
| `sellerType` | String | Raw seller classification: agency, broker, user/private (detail fetch only) |
| `sellerName` | String | Agency, broker or private seller name |
| `images` | Array | All listing photos (detail fetch only) |
| `energyCertificate` | String | Energy performance class, when listed (detail fetch only) |
| `heatingType` | String | Heating system (detail fetch only) |
| `yearBuilt` | String | Construction year (detail fetch only) |
| `constructionType` | String | Building material, e.g. "Mūrinis" (brick) (detail fetch only) |

#### Example output

```json
{
    "listingId": 8779649,
    "listingTitle": "4 kambarių butas Klaipėdoje, Debrecene, Debreceno g.",
    "price": 110000,
    "currency": "EUR",
    "pricePerSqm": 1428.57,
    "area": 77,
    "rooms": 4,
    "floor": "5/5",
    "location": "Klaipėda, Debrecenas, Debreceno g.",
    "propertyType": "apartment",
    "transactionType": "sale",
    "imageUrl": "https://domoplius.lt/storage/photos/1/87796/49/....jpg",
    "url": "https://domoplius.lt/skelbimai/parduodamas-4-kambariu-butas-klaipedoje-debrecene-debreceno-g-8779649.html",
    "listingDescription": "Klaipedoje, Debreceno g. parduodamas 4 kambariu butas...",
    "scrapedAt": "2026-09-09T14:28:00.033Z",
    "latitude": 55.6836245,
    "longitude": 21.1753611,
    "city": "Klaipėda",
    "microdistrict": "Debrecenas",
    "datePosted": "2026-08-19",
    "sellerType": "broker",
    "sellerName": "UAB Avitera",
    "images": ["https://domoplius.lt/storage/photos/1/87796/49/....jpg", "..."],
    "energyCertificate": null,
    "heatingType": "Centrinis šildymas",
    "yearBuilt": "1972",
    "constructionType": "Blokinis"
}
```

### Categories

| Category | Slug | Notes |
|----------|------|-------|
| Apartments | `butai` | Largest category, ~3,800 active listings |
| Houses & cottages | `namai-kotedzai-sodai` | Houses, cottages, garden plots with a building |
| Commercial | `komercines-patalpos` | Offices, retail, warehouse space |
| Land | `sklypai` | Land plots |
| Garages | `garazai` | Smallest category, ~40 active listings |

### Anti-bot protection

Domoplius.lt sits behind a whole-site Cloudflare Turnstile managed challenge — even `robots.txt` is gated. The actor passes this automatically using a patched Firefox browser (Camoufox) through a Lithuanian residential IP, then reuses the resulting clearance cookie for fast plain-HTTP requests against the site's own JSON API for the rest of the run. If the clearance expires mid-run, the actor detects it by content (not just HTTP status) and re-warms automatically.

### Cost estimate

This actor uses a Lithuanian **residential** proxy, which is the most expensive proxy tier — real estate sites with a Cloudflare gate like this one cost more per result than an unprotected e-commerce site. Expect roughly **20-40 compute units per 1,000 results** with detail fetching on (one extra request per listing), lower with it off. Usage cost only settles on the platform after a run reports **SUCCEEDED** — reading the dataset while a run is still in progress undercounts the eventual cost.

### Limitations

- No free-text search — filter by category and listing type only
- The actor extracts publicly available data only — no login or authentication required
- Some fields (energy certificate, heating type, construction type) are only present when the seller filled them in on the original listing — this is a source-data gap, not a scraping gap
- `fetchDetails: false` returns a thinner record with no GPS, description, building details, or full photo set

### Maintained by Studio Amba

We run 700+ scrapers for European websites, and the priority is keeping every one of them working. Automated runs test this actor against the live site and verify the output is complete. When the website changes, the scraper usually gets repaired the same day, without you having to report anything. Questions and issues go straight to the people who built it, and most get an answer the same day.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs, deduplication, delta detection, and delivery to your inbox, Google Sheets, or API, maintenance included. We can also build a custom version with your exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email <hello@studioamba.dev> for a free data sample.

# Actor input Schema

## `propertyType` (type: `string`):

Which Domoplius.lt real estate category to scrape.

## `listingType` (type: `string`):

For sale (Parduoti) or for rent (Nuomotis). Always applied explicitly — Domoplius mixes both together when this filter is omitted.

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

Stop after this many listings. The largest category (apartments) has roughly 3,800 active listings, so a hard cap keeps runs bounded. One extra request per result is spent when detail fetching is on.

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

On (default): open each listing's detail page for GPS coordinates, full description, all photos, building details (heating, construction, energy certificate) and the exact posting date. Off: a faster, thinner scan using only the search-card fields (title, price, city, microdistrict, one image) — no GPS, no description, no building details. This flag changes how COMPLETE each record is, not just how many you get.

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

RESIDENTIAL + country LT is required. Domoplius.lt sits behind a whole-site Cloudflare Turnstile clearance gate (see docs/site-recon/domoplius-lt.md) — a Lithuanian residential IP is the only pool confirmed to pass it. Do not switch this off.

## Actor input object example

```json
{
  "propertyType": "butai",
  "listingType": "sale",
  "maxResults": 20,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LT"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "propertyType": "butai",
    "listingType": "sale",
    "maxResults": 20,
    "fetchDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "LT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/domoplius-lt-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 = {
    "propertyType": "butai",
    "listingType": "sale",
    "maxResults": 20,
    "fetchDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "LT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/domoplius-lt-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 '{
  "propertyType": "butai",
  "listingType": "sale",
  "maxResults": 20,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LT"
  }
}' |
apify call studio-amba/domoplius-lt-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/domoplius-lt-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/vHNDPih0yOlUafnCB/builds/E1wfM5zzDSVNfmA90/openapi.json