# Aruodas Property Scraper (`sian.agency/aruodas-property-scraper`) Actor

Scrape Aruodas.lt, Lithuania's number-one property portal: asking price, price per square metre, size, rooms, floor, year built, heating, energy class, GPS and the advertiser's phone. Sale and rent, apartments to plots, every city. JSON, CSV or Excel.

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

## Pricing

from $1.32 / 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

## Aruodas Scraper - Lithuanian Property Listings 🏘️

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Otodom Poland](https://img.shields.io/badge/Store-Otodom%20Poland-1AE392)](https://apify.com/sian.agency/otodom-property-scraper?fpr=sian) [![Hemnet Sweden](https://img.shields.io/badge/Store-Hemnet%20Sweden-DA0060)](https://apify.com/sian.agency/hemnet-property-scraper?fpr=sian) [![Sreality Czechia](https://img.shields.io/badge/Store-Sreality%20Czechia-CC0000)](https://apify.com/sian.agency/sreality-property-scraper?fpr=sian)

#### 🎉 Every live advert on Lithuania's number-one property portal, from $1.50 per 1,000 properties

##### Built for Lithuanian estate agents, valuers, developers, lenders and anyone pricing Vilnius property

***

### 🔎 What is the Aruodas Property Scraper — and when should you use it?

The **Aruodas Property Scraper** turns any Aruodas.lt search on Lithuania's number-one property portal 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:** asking prices in euros, price per square metre already computed, floor area, plot area in ares, rooms, floor out of total floors, year built, heating type, finish, building type and energy class, for property to buy or to rent anywhere in Lithuania. Rows carry the district and street, the photo set, and whether the listing belongs to a new development. Turning on full detail adds the advertiser's name and phone number, the whole advert text, window orientation, map coordinates and every photo on the advert rather than the four the results row shows.

**Use something else when:** the property is outside Lithuania. Use [Otodom Property Scraper](https://apify.com/sian.agency/otodom-property-scraper?fpr=sian) for Poland, Lithuania's largest neighbour. Use [Hemnet Scraper](https://apify.com/sian.agency/hemnet-property-scraper?fpr=sian) for Sweden, with sold prices as well as live adverts. Use [Sreality Scraper](https://apify.com/sian.agency/sreality-property-scraper?fpr=sian) for Czechia. This actor reads live Aruodas adverts only. Sold prices and transaction history are not available from any scraper of this source, because Lithuania's transaction register is not public — use `listedWithinDays` to watch new supply instead. Land plots and garages are advertised for sale only, so a rent run on either is refused rather than quietly returning sale adverts. Skelbiu.lt and the rest of the Lithuanian long tail are different portals and are out of scope. Latvia and Estonia are not covered by this actor either.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/aruodas-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 to research the Lithuanian property market, for sale or to rent, from the portal that holds most of it using the Apify Actor `sian.agency/aruodas-property-scraper`.

Use it when I need: asking prices in euros, price per square metre already computed, floor area, plot area in ares, rooms, floor out of total floors, year built, heating type, finish, building type and energy class, for property to buy or to rent anywhere in Lithuania. Rows carry the district and street, the photo set, and whether the listing belongs to a new development. Turning on full detail adds the advertiser's name and phone number, the whole advert text, window orientation, map coordinates and every photo on the advert rather than the four the results row shows.

Don't use it when: the property is outside Lithuania — use otodom-property-scraper or hemnet-property-scraper or sreality-property-scraper instead.

How to call it: give `locations` one or more of the 48 offered places (`vilniuje`, `kaune`, `klaipedoje`, `siauliuose`, `panevezyje`, `palangoje` and so on) or `all-lithuania` for the whole country, then set `listingType` to `sale` or `rent` and `propertyCategory` to one of `apartment`, `house`, `homestead`, `commercial`, `land` or `garage`. Narrow with `priceMin`, `priceMax`, `pricePerSqmMax`, `areaMin`, `areaMax`, `roomsMin`, `roomsMax`, `floorMin`, `floorMax`, `buildYearMin`, `buildYearMax` and `listedWithinDays`, and order the results with `sortBy`. Every one of those filters was checked against the live result count before being offered, so none of them is decorative. `fetchDetails` opens each advert page as well and adds the advertiser's phone, the full text, energy class and coordinates, for an extra charge per property. If you already built a search on aruodas.lt itself, paste the address bar into `searchUrls` and it is fetched exactly as given.

Start with this input:
{
  "locations": [
    "vilniuje"
  ],
  "listingType": "sale",
  "propertyCategory": "apartment",
  "roomsMin": 2,
  "priceMax": 250000,
  "maxResults": 120
}

Ask me which cities or towns they want, whether they are buying or renting, and which kind of property — apartments, houses, homesteads, commercial premises, land or garages, then run the Actor and summarise the results as a table.
```

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

- *Pull two-room apartments for sale under 200,000 euro in Vilnius and Kaunas and rank them by price per square metre.*
- *Compare asking rent per square metre in Vilnius Old Town against Šnipiškės and tell me which is better value.*
- *List every land plot advertised in Lithuania in the last week with its plot size and price per square metre.*
- *Find new-build apartments in Klaipėda finished since 2020, then get the developer's phone number for each.*

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

### 📋 Overview

**Lithuanian property advertising runs through one dominant website, and that website publishes no API.** This Actor reads the portal's own public results pages and hands you every live advert as a flat row. Sale and rent, Vilnius down to Neringa, apartments through to garages.

**Why professionals choose it:**

- ✅ **The fields a Lithuanian valuation actually needs**: asking price, price per square metre, floor area, rooms, floor and floors in the building, construction year, heating, finish and building type, returned as typed numbers and labels rather than text to clean up afterwards.
- 🇱🇹 **All of Lithuania, or one town.** 48 named cities and towns, plus a nationwide sweep. Around 7,600 apartments are advertised for sale across the country at any one time, and the Actor will walk every one of them if you raise the row cap.
- 🎛️ **12 filters, all applied before the rows are counted.** Price, price per square metre, size, rooms, floor, construction year and the recency window narrow the search at source, so you pay for the properties you asked for. Five sort orders decide which properties a capped run sees first.
- 📞 **The advertiser's name and phone number** come with full listing detail, which turns a price list into a call list.
- 💰 **$1.50 per 1,000 properties**, charged per delivered row and never for a row that failed.
- 🗺️ **You get the town you asked for.** Aruodas answers an unfamiliar place name with the whole country instead of an error, so the town list here is a fixed set and anything outside it is refused before a single row is charged.

***

### ✨ Features

- 🏘️ **Six property classes in one Actor**: apartments, houses, homesteads, commercial premises, land plots, and garages and parking. Land and garages are advertised for sale only, and asking for them to rent is refused before anything is charged rather than quietly answered with sale adverts.
- 📞 **Advertiser name, phone number and type** on every detailed row, whether the advert comes from an agency or a private seller.
- 📸 **The complete photo set.** A new-build advert commonly carries around 28 photos where its results row carries 4.
- ⚡ **Energy class as the portal grades it**, from A++ downwards, alongside the building type and the window orientation.
- 🧭 **Map coordinates** on detailed rows, so results drop straight onto a map.
- 🏗️ **New builds flagged**, with the development's own name on the row when the advert gives one.
- 🌳 **Plot size in ares**, the unit Lithuanian land adverts actually use, kept separate from built floor area.
- 🆕 **Recency windows from 24 hours to 30 days**, which turns a scheduled run into a cheap new-supply monitor.
- 🔗 **Paste an Aruodas search link.** Set the filters on the site, copy the address bar, and the Actor reads that search and pages through it.
- 📊 **45 flat fields**: export as CSV, Excel or JSON, or pull them over the API.

***

### 🎬 Quick Start

Pick a town, choose sale or rent, press Start. Rows land in the dataset as they are found, and a run report is written to the key-value store with the counts and what they cost. Nothing else needs configuring.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~aruodas-property-scraper/runs?token=YOUR_TOKEN" \
-H 'Content-Type: application/json' \
-d '{"locations":["vilniuje"],"listingType":"sale","propertyCategory":"apartment","maxResults":100}'
```

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your towns

Pick from the list: Vilnius, Kaunas, Klaipėda, Šiauliai, Panevėžys and 43 more, or All Lithuania for the whole country in one sweep. One search runs per town, and every row is stamped with the town it came from.

#### Step 2: Choose the market and the property type

For sale is much the larger pool nationwide. Apartments are the default; houses, homesteads, commercial premises, land plots and garages are one dropdown away.

#### Step 3: Press Start

Add price, size, room, floor or construction-year bounds if you want them, and set how many rows to collect. Switch on Full listing detail when you need the advertiser's phone number and the whole advert.

**That's it. Within a minute or two you'll have:**

- Every matching property as a spreadsheet row
- Price per square metre already calculated on each one
- A run report showing what was found, what failed and what it cost

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|---|---|---|---|
| `locations` | array | No | Towns to search, from the fixed list. `all-lithuania` sweeps the whole country. Default `vilniuje` |
| `listingType` | string | No | `sale` (default) or `rent` |
| `propertyCategory` | string | No | `apartment` (default), `house`, `homestead`, `commercial`, `land` or `garage` |
| `maxResults` | integer | No | Rows to collect across every town in the run. Default 100, up to 20,000 |
| `fetchDetails` | boolean | No | Open each advert page for the advertiser's phone, full text, energy class, coordinates and all photos |
| `priceMin` / `priceMax` | integer | No | Price bounds in euro; monthly rent on rentals. 0 means no bound |
| `pricePerSqmMax` | integer | No | Ceiling on the portal's own price per square metre |
| `areaMin` / `areaMax` | integer | No | Floor-area bounds in square metres |
| `roomsMin` / `roomsMax` | integer | No | Room bounds. Lithuanian adverts count rooms, so a two-room flat is a one-bedroom |
| `floorMin` / `floorMax` | integer | No | Floor bounds. Set `floorMin` to 2 to skip ground-floor flats |
| `buildYearMin` / `buildYearMax` | integer | No | Construction-year bounds |
| `listedWithinDays` | string | No | `0` for any time, or `1`, `2`, `3`, `7`, `30` days since the advert was published |
| `sortBy` | string | No | `Importance` (portal default), `AddDate`, `Price`, `PriceExp` or `AreaOverall` |
| `searchUrls` | array | No | Paste finished aruodas.lt search links instead of filling the fields above |

**Example: two-room Vilnius flats under €200,000, newest first**

```json
{
  "locations": ["vilniuje"],
  "listingType": "sale",
  "propertyCategory": "apartment",
  "roomsMin": 2,
  "roomsMax": 2,
  "priceMax": 200000,
  "sortBy": "AddDate",
  "maxResults": 200
}
```

**Example: everything listed in the last 24 hours in three cities, with advertiser phone numbers**

```json
{
  "locations": ["vilniuje", "kaune", "klaipedoje"],
  "listingType": "sale",
  "propertyCategory": "apartment",
  "listedWithinDays": "1",
  "fetchDetails": true,
  "maxResults": 150
}
```

**Example: land plots around Trakai, with coordinates and the full advert text**

```json
{
  "locations": ["trakuose"],
  "listingType": "sale",
  "propertyCategory": "land",
  "priceMax": 60000,
  "fetchDetails": true,
  "maxResults": 100
}
```

**Example: a search you built on the site yourself**

```json
{
  "searchUrls": ["https://www.aruodas.lt/butai/vilniuje/?FPriceMax=200000"],
  "maxResults": 300
}
```

***

### 📤 Output

Every row is flat JSON with **45 fields**. The ones people use most:

| Field | Type | Description |
|---|---|---|
| `propertyTitle` | string | Town, district, street and property type, as the advert is headed |
| `listingUrl` | string | Working link back to the advert on Aruodas |
| `price` / `priceText` | number / string | Asking price in euro, and the price exactly as the portal prints it |
| `pricePerSqm` | number | Price per square metre: capital price on sale, monthly rent on rentals |
| `areaSqm` / `plotAreaAres` | number | Built floor area in square metres, plot area in ares |
| `rooms` / `floor` / `floorsTotal` | integer | Room count, the floor it is on, and floors in the building |
| `buildYear` | integer | Construction year |
| `heating` / `condition` / `buildingType` | string | Heating system, state of finish and construction type |
| `energyClass` | string | Energy grade as the portal publishes it, e.g. A++ (full detail) |
| `city` / `district` / `street` / `addressText` | string | Location breakdown and the address line |
| `latitude` / `longitude` | number | Map coordinates (full detail) |
| `sellerName` / `sellerPhone` / `sellerType` | string | Advertiser name, phone number and whether it is an agency (full detail) |
| `descriptionText` | string | The full advert text as written (full detail) |
| `isNewDevelopment` / `projectName` | boolean / string | New-build flag and the development's name |
| `imageUrls` / `photoCount` / `mainImageUrl` | array / integer / string | Every photo on the advert, the count, and the cover image |
| `attributes` | object | The portal's own attribute table, key by key (full detail) |
| `windowOrientation` / `houseNumber` | string | Which way the windows face, and the house number (full detail) |
| `searchUrl` / `searchPage` / `scrapedAt` | string / integer / string | Which search and which results page the row came from, and when |
| `hasDetail` / `status` / `errorMessage` | boolean / string / string | Whether the advert page was read, and the row's outcome |

**Example row: a Vilnius new-build with full listing detail on**

```json
{
  "listingId": 3661652,
  "listingUid": "1-3661652",
  "listingUrl": "https://www.aruodas.lt/butai-vilniuje-siaures-miestelyje-kareiviu-g-citus-munai-bene-populiariausias-projektas-1-3661652/",
  "propertyTitle": "Vilnius, Šiaurės miestelis, Kareivių g., 2 kambarių butas",
  "listingType": "sale",
  "propertyCategory": "apartment",
  "city": "Vilnius",
  "district": "Šiaurės miestelis",
  "street": "Kareivių g.",
  "houseNumber": "5",
  "addressText": "Vilnius, Šiaurės miestelis, Kareivių g.",
  "price": 190650,
  "priceText": "190 650 €",
  "currency": "EUR",
  "pricePerSqm": 3743,
  "rooms": 2,
  "areaSqm": 50.94,
  "floor": 4,
  "floorsTotal": 8,
  "buildYear": 2025,
  "heating": "Centrinis kolektorinis",
  "condition": "Dalinė apdaila",
  "buildingType": "Monolitinis",
  "energyClass": "A++",
  "windowOrientation": "Šiaurė, pietūs",
  "isNewDevelopment": true,
  "projectName": "CITUS Mūnai",
  "sellerName": "CITUS Mūnai",
  "sellerPhone": "+370 691 38122",
  "latitude": 54.715076,
  "longitude": 25.29127,
  "photoCount": 24,
  "hasDetail": true,
  "searchUrl": "https://www.aruodas.lt/butai/vilniuje/?FPriceMax=200000",
  "searchPage": 1,
  "scrapedAt": "2026-09-06T10:05:24.635Z",
  "status": "success"
}
```

#### Coverage

The whole of Lithuania: 48 named cities and towns individually, or the country in a single sweep. Both sides of the market, and six property classes. Land plots and garages are advertised for sale only, so a rent run on either is refused with that message rather than answered with sale adverts. Sold prices and transaction history are **not** available: Aruodas publishes live adverts only, and Lithuania's transaction register is not public. The nearest signal is the recency window, which returns what came onto the market in the last day.

***

### 💼 Use Cases & Examples

#### 1. Rental-yield maths across Lithuanian cities

**Investors and lettings operators pricing a district before they buy.**

**Input:** The same town swept twice, once for sale and once to rent.
**Output:** Price per square metre on both sides, with the district on every row.
**Use:** Join on district and divide. The sale rows carry capital price per square metre and the rental rows carry monthly rent per square metre, and the sale-or-rent flag on each row keeps the two apart.

#### 2. Watching what agents just listed

**Agencies and portals that need to see new supply first.**

**Input:** The recency window set to 24 hours, scheduled daily.
**Output:** Only adverts published since yesterday, with price, size, district, street, construction year and finish.
**Use:** This is as close to a transaction feed as Lithuania publishes, since the sold-price register is closed. Switch on full detail and each new advert arrives with the advertiser's name and phone number.

#### 3. Land and development site sourcing

**Developers and site finders looking for plots.**

**Input:** Land plots in a municipality, with a price ceiling and a price-per-square-metre ceiling.
**Output:** Plots with their area in ares, asking price, address and, with full detail on, map coordinates and the whole advert text.
**Use:** Shortlist sites without opening 300 adverts by hand, then hand the coordinates to a GIS layer.

#### 4. Valuation comparables for banks and surveyors

**Lenders, valuers and surveyors building a comparable set.**

**Input:** A district with a size band and a room band, exported to Excel.
**Output:** Price, price per square metre, floor, floors in the building, construction year, heating and finish, as typed numbers and labels.
**Use:** Drop the sheet straight into a valuation model. Nothing needs parsing out of free text first.

#### 5. Live rental stock for relocation and lettings platforms

**Relocation advisers and rental marketplaces keeping a feed fresh.**

**Input:** Rentals in several cities at once with a monthly ceiling and a room minimum, refreshed on a schedule.
**Output:** Every matching rental with photos as URLs.
**Use:** Render listings on your own site without a second fetch for images, and refresh the whole set overnight.

#### 6. Asking-price tracking by city and district

**Analysts and economists tracking the Lithuanian market week by week.**

**Input:** The same nationwide search run weekly.
**Output:** Every live advert with price, size and price per square metre.
**Use:** Diff one week against the next to build a price index. Around 7,600 apartments are advertised for sale nationwide, and Vilnius apartments alone run to 118 results pages.

***

### 🔗 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/aruodas-property-scraper').call({
  locations: ['vilniuje', 'kaune'],
  listingType: 'sale',
  propertyCategory: 'apartment',
  roomsMin: 2,
  priceMax: 250000,
  maxResults: 300,
});

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/aruodas-property-scraper').call(run_input={
    'locations': ['klaipedoje'],
    'listingType': 'rent',
    'propertyCategory': 'apartment',
    'fetchDetails': True,
    'maxResults': 150,
})

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

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~aruodas-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"locations":["all-lithuania"],"listingType":"sale","propertyCategory":"land","maxResults":250}'
```

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

1. **Trigger**: a daily schedule
2. **HTTP Request**: call the Actor with `listedWithinDays` set to `1`
3. **Process**: filter the returned rows on your own criteria
4. **Action**: append to Google Sheets, push into a CRM, or fire a Slack alert

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 properties** per run, with every field and every filter available
- No credit card needed
- Enough to confirm the data is what you need before you scale

#### PAID Tier (Production Ready)

- **Up to 20,000 properties** in a single run, across as many towns as you pick
- Charged per delivered row. Failed rows are never billed
- 25 properties per results page, at roughly a second a page

💰 **$1.50 per 1,000 properties** on paid Apify plans. Full listing detail, which opens the advert page for the advertiser's phone number, the full text, the energy class, coordinates and every photo, costs $3.50 per 1,000 on top and only when you switch it on. Starting a run costs $0.005. On the free Apify plan the same rows are $6.00 per 1,000 with a $0.02 run start, drawn from your monthly Apify credits.

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

***

### ❓ Frequently Asked Questions

**Q: Do I need an Aruodas account or an API key?**
A: No. Pick a town and press Start.

**Q: How many properties can I get in one run?**
A: On the free Apify plan, 25 per run. On a paid plan, up to 20,000 rows in a single run, spread across as many towns as you pick.

**Q: Does it cover the whole of Lithuania?**
A: Yes. Pick any of the 48 named cities and towns, several at once, or All Lithuania for the country in one sweep. Nationwide apartment sales alone run to about 7,600 live adverts.

**Q: Can I get sold prices?**
A: No, and no scraper of this source can. Aruodas publishes live adverts only, and Lithuania's transaction register is not public. Use the "listed in the last 24 hours" filter to track new supply instead.

**Q: Do I get the advertiser's phone number?**
A: Yes, when you turn on Full listing detail. The phone number, the advertiser's name, the full advert text, the energy class, map coordinates and every photo all come from the advert page, which is charged as a second event per property.

**Q: Why is the price per square metre on my rent search so much lower than on a sale search?**
A: Because it is a different number. On a rent advert it is the monthly rent per square metre; on a sale advert it is the capital price per square metre. Every row carries the sale-or-rent flag, so the two are never mixed.

**Q: Can I paste a search URL I built on the site?**
A: Yes. Set your filters on aruodas.lt, copy the address bar and paste it into the search-URLs field. The Actor fetches that search exactly as given and pages through it.

**Q: How fast is it?**
A: About a second per results page of 25 properties, so a thousand rows is roughly forty page fetches rather than a thousand page loads. Full listing detail adds one advert page per property.

**Q: What happens if a page cannot be read?**
A: It is retried automatically. If the portal still will not serve it, the run reports how many pages could not be read rather than quietly returning a short result set, and you are not charged for rows that never arrived.

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

***

### 🐛 Troubleshooting

**Fewer rows than I asked for**

- The search genuinely has fewer live adverts than your row cap. The run log prints how many results pages exist before it starts paging.
- On the FREE tier every run stops at 25 rows.

**A rent search was refused**

- Land plots and garages are advertised for sale only on Aruodas. Set the market to For sale, or pick another property type.

**Energy class, coordinates or the advertiser's phone number came back empty**

- Those live on the advert's own page. Switch on Full listing detail and they appear on every row.

**No results at all**

- The filters are too narrow. Widen the price band first, then the size and room bands, since those cut hardest.
- Check the construction-year bounds. A minimum of 2015 removes most of the stock in smaller towns.

**A run says a page is temporarily unavailable**

- The portal occasionally refuses a burst of visitors. The Actor already retries; if a run still finishes short, start it again shortly afterwards. Rows that did not arrive are not charged.

**The run stopped and mentioned a free-run limit**

- Free Apify plans get 10 unbilled runs and 30 runs in total per day on this Actor, and the count resets at 00:00 UTC. Adding credits or a payment method in Apify Console lifts it.

***

### ⚖️ 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/).

***

### 🤝 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 tab](https://apify.com/sian.agency/aruodas-property-scraper/issues)
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

Aruodas.lt is a trademark of UAB Diginet LTU. This actor is not affiliated with, endorsed by, or sponsored by Aruodas.

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

# Actor input Schema

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

Where in Lithuania to search. Pick one place, several, or All Lithuania for the whole country in one sweep. One search runs per place and every row is stamped with the city it came from. The list is a fixed set on purpose: Aruodas answers an unknown place name with the WHOLE country instead of an error, so a free-text box would quietly bill you for the wrong result set.

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

Which side of the market to read. For sale is much the larger pool nationwide. Land plots and garages are advertised for sale only on Aruodas, so those two are refused with rent rather than falling back to sale adverts.

## `propertyCategory` (type: `string`):

Which kind of property. Apartments and houses each have separate sale and rent sections; homesteads and commercial premises do too. Land plots and garages exist for sale only.

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

How many properties to return in total. When you pick several places the budget is shared evenly between them, and whatever one search does not use passes to the next — so choosing three cities gives you all three, not 100 rows of the first. Pages are 25 rows, so a search stops on the page that reaches its share. Nationwide apartment sales hold roughly 7,600 live adverts if you want the lot.

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

Open every advert page as well as the results list, to add the advertiser's name and phone number, the full advert text, energy class, building type, window orientation, map coordinates and the complete photo set — 28 photos on a typical new-build against the 4 a results row carries. This fetches one extra page per property and bills the Full listing detail event per row, so leave it off for a price sweep and turn it on for a lead list.

## `priceMin` (type: `integer`):

Lowest asking price to include, in euros. For rentals this is the monthly rent. Leave at 0 for no floor.

## `priceMax` (type: `integer`):

Highest asking price to include, in euros; for rentals, the monthly rent. Leave at 0 for no ceiling.

## `pricePerSqmMax` (type: `integer`):

Ceiling on the portal's own price-per-square-metre figure — capital price per m² on a sale advert, monthly rent per m² on a rental. Useful for finding value without fixing a total budget. 0 means no ceiling.

## `areaMin` (type: `integer`):

Smallest floor area to include, in square metres. 0 means no floor.

## `areaMax` (type: `integer`):

Largest floor area to include, in square metres. 0 means no ceiling.

## `roomsMin` (type: `integer`):

Fewest rooms to include. Lithuanian adverts count rooms, not bedrooms, so a two-room flat is a one-bedroom. 0 means no floor.

## `roomsMax` (type: `integer`):

Most rooms to include. 0 means no ceiling.

## `floorMin` (type: `integer`):

Lowest floor to include — set 2 to skip ground-floor flats. 0 means no floor.

## `floorMax` (type: `integer`):

Highest floor to include. 0 means no ceiling.

## `buildYearMin` (type: `integer`):

Earliest construction year to include — set 2015 to see modern stock only. 0 means no floor.

## `buildYearMax` (type: `integer`):

Latest construction year to include. 0 means no ceiling.

## `listedWithinDays` (type: `string`):

Only adverts published inside this window. This is the closest Aruodas gets to a transaction feed — Lithuania has no public sold-price register — so a daily run with 24 hours is how you watch new supply arrive.

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

How Aruodas orders the results before the actor reads them. It changes which properties you get first when you cap the row count, not how many exist.

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

Optional. Set your filters on aruodas.lt, copy the URL out of the address bar and paste it here — the actor fetches it exactly as given and paginates from there. When this is filled in it replaces the city, sale-or-rent, property-type and filter fields above; everything else, including the row cap and Full listing detail, still applies.

## Actor input object example

```json
{
  "locations": [
    "vilniuje",
    "kaune"
  ],
  "listingType": "sale",
  "propertyCategory": "apartment",
  "maxResults": 100,
  "fetchDetails": false,
  "priceMin": 0,
  "priceMax": 0,
  "pricePerSqmMax": 0,
  "areaMin": 0,
  "areaMax": 0,
  "roomsMin": 0,
  "roomsMax": 0,
  "floorMin": 0,
  "floorMax": 0,
  "buildYearMin": 0,
  "buildYearMax": 0,
  "listedWithinDays": "0",
  "sortBy": "Importance",
  "searchUrls": []
}
```

# Actor output Schema

## `aruodasLtProperties` (type: `string`):

Every property 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 = {
    "locations": [
        "vilniuje",
        "kaune"
    ],
    "listingType": "sale",
    "propertyCategory": "apartment",
    "maxResults": 100,
    "fetchDetails": false,
    "priceMin": 0,
    "priceMax": 0,
    "pricePerSqmMax": 0,
    "areaMin": 0,
    "areaMax": 0,
    "roomsMin": 0,
    "roomsMax": 0,
    "floorMin": 0,
    "floorMax": 0,
    "buildYearMin": 0,
    "buildYearMax": 0,
    "listedWithinDays": "0",
    "sortBy": "Importance",
    "searchUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/aruodas-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 = {
    "locations": [
        "vilniuje",
        "kaune",
    ],
    "listingType": "sale",
    "propertyCategory": "apartment",
    "maxResults": 100,
    "fetchDetails": False,
    "priceMin": 0,
    "priceMax": 0,
    "pricePerSqmMax": 0,
    "areaMin": 0,
    "areaMax": 0,
    "roomsMin": 0,
    "roomsMax": 0,
    "floorMin": 0,
    "floorMax": 0,
    "buildYearMin": 0,
    "buildYearMax": 0,
    "listedWithinDays": "0",
    "sortBy": "Importance",
    "searchUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/aruodas-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 '{
  "locations": [
    "vilniuje",
    "kaune"
  ],
  "listingType": "sale",
  "propertyCategory": "apartment",
  "maxResults": 100,
  "fetchDetails": false,
  "priceMin": 0,
  "priceMax": 0,
  "pricePerSqmMax": 0,
  "areaMin": 0,
  "areaMax": 0,
  "roomsMin": 0,
  "roomsMax": 0,
  "floorMin": 0,
  "floorMax": 0,
  "buildYearMin": 0,
  "buildYearMax": 0,
  "listedWithinDays": "0",
  "sortBy": "Importance",
  "searchUrls": []
}' |
apify call sian.agency/aruodas-property-scraper --silent --output-dataset

```

## MCP server setup

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