# Aruodas.lt Property Listings Scraper (`bovi/aruodas-scraper`) Actor

Collect Aruodas property listings as structured records with IDs, URLs, prices, areas, rooms, locations, and available photo URLs. Run with listing or search URLs; no login or buyer API key. Pricing: $0.01 per dataset item on Free plan. Unshown fields are absent.

- **URL**: https://apify.com/bovi/aruodas-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 53.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 aruodas.lt property listings scrapers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Aruodas.lt Property Listings Scraper

For property-data buyers, this Actor extracts structured public listing cards from Aruodas.lt, including IDs, URLs, prices, areas, rooms, locations, and available photo URLs. It does not require a buyer-supplied API key or an Aruodas login.

- Collect property listings with IDs, URLs, classifications, prices, and locations for property-market research.
- Compare asking prices, price per square metre, areas, and room counts across Aruodas search results.
- Build location-focused property listing datasets from Aruodas category or search URLs.
- Export structured results without requesting advertiser contact details or signing in to Aruodas.

### What you get

The Actor reads listing cards that Aruodas serves as HTML. One returned property becomes one structured dataset item.

| Field | Type | What it contains |
|---|---|---|
| `id` | string | Aruodas listing ID; not empty on returned records |
| `url` | string | Listing URL; not empty on returned records |
| `title` | string | Listing title; not empty on returned records |
| `property_type` | string | Property type classified from the listing URL |
| `listing_type` | string | Sale or rent classification; not empty on returned records |
| `location` | string | Listing location |
| `address` | string | Address or listing-card address |
| `price_eur` | number | Asking price in euros; not empty on returned records |
| `price_per_sqm_eur` | number | Price per square metre in euros |
| `area_sqm` | number | Property area in square metres |
| `rooms` | number | Room count |
| `floor` | integer | Property floor |
| `building_floors` | integer | Total building floors |
| `build_year` | integer | Construction year |
| `photo_urls` | array of strings | Available listing photo URLs; empty when no photo URLs are found |

The parser recognizes property classifications including apartments, houses, land, commercial properties, garages, and homesteads when the corresponding Aruodas URL pattern is present. Sale listings commonly omit a sale word in their URL, while rental listings contain rental wording.

### Sample output

One real dataset record:

```json
{
  "id": "3712486",
  "url": "https://www.aruodas.lt/butai-vilniuje-santariskese-santariskiu-g-parduodame-sviesu-ir-erdvu-ju-kambariu-buta-1-3712486/",
  "title": "Vilnius, Santariškės, Santariškių g., 2 kambarių butas",
  "property_type": "apartment",
  "listing_type": "sale",
  "price_eur": 192000,
  "photo_urls": ["https://aruodas-img.dgn.lt/object_66_126197913/nuotrauka.jpg"],
  "location": "Vilnius",
  "address": "Vilnius, Santariškės, Santariškių g., 2 kambarių butas",
  "price_per_sqm_eur": 3333,
  "area_sqm": 57.6,
  "rooms": 2
}
```

### Pricing

The current billing model charges the buyer per event. Actor charges are based on these events:

- `apify-actor-start`: $0.00005 per event on the Free plan. This event is charged when the Actor starts; the number of events depends on Actor memory, with one event per GB and a minimum of one event. 1,000 events = $0.05 on Free and 10,000 events = $0.50 on Free.
- `apify-default-dataset-item`: $0.01 per event on the Free plan. One event represents one scraped result with all fields. 1,000 events = $10 on Free and 10,000 events = $100 on Free.

One returned property is one dataset item. Failed or empty pages do not create result items. A run with one Actor Start event and 499 returned properties costs $0.00005 on Free for the start event plus $0.01 per result on Free, for a total of **499 results = $4.99005 on Free**.

The Apify Free plan includes $5 of monthly platform usage credit; the $5 Free-plan credit covers 499 results (with one Actor Start event).

You pay only for the events listed above. This Actor does not use the Pay per event + usage option, so the platform usage of your runs (compute, proxy traffic and storage) is not billed to you separately.

### How to use

1. **Open** the Actor in Apify and provide an Apify run input.
2. **Enter** one or more `aruodas.lt` URLs in `searchUrls`. The default is the homepage, which is read as one page of featured cards. For larger runs, enter a category or search URL (copy it from your browser after filtering on Aruodas.lt); the Actor follows pagination for such URLs. To check what a URL returns, run it with `maxResults` set to `1`.
3. **Set** `maxResults` to the maximum number of unique listings to return.
4. **Leave** `proxyConfiguration` at its default (Apify Proxy, RESIDENTIAL group). Change it only if you need other proxy settings; if you disable the proxy, requests go directly to Aruodas.lt, which may deny them.
5. **Run** the Actor. It pushes accepted listings to the dataset, reads listing cards from HTML, deduplicates results by listing ID, and stops after the requested number of unique listings.
6. **Review** the dataset.
7. **Schedule** the run through Apify Schedules for repeated extraction.

Example input (`proxyConfiguration` is not listed, so it takes its default, Apify Proxy with the RESIDENTIAL group):

```json
{
  "searchUrls": ["https://www.aruodas.lt/"],
  "maxResults": 50
}
```

Export the dataset as JSON or CSV, or read it through the Apify dataset API.

### Input parameters

| Parameter | What it does | Default |
|---|---|---|
| `searchUrls` | List of one or more HTTP or HTTPS Aruodas listing or search URLs. Only `aruodas.lt` and its subdomains are accepted. The Actor deduplicates returned listings by listing ID. | `["https://www.aruodas.lt/"]` |
| `maxResults` | Maximum number of unique property listings to return. Use an integer from 1 through 20000. | `50` |
| `proxyConfiguration` | Apify Proxy settings for the run. When disabled or omitted, requests go directly to Aruodas.lt. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

### Limits and edge cases

| Condition | What you see | What to do |
|---|---|---|
| The default URL (the homepage) is used | The homepage is read as one page of featured cards, so `maxResults` of 50 may return fewer items. | Add category or search URLs to `searchUrls` for larger runs. |
| Aruodas denies a direct request to a category or search URL, returning an HTTP 4xx response | The run fails with an error naming the HTTP status and URL; records already pushed remain. | Keep the default Apify Proxy (RESIDENTIAL) enabled and check that the URL opens in a browser. |
| A page contains no parsable records, or contains no new unique listing IDs | Pagination stops for that starting URL, so the dataset can contain fewer items than `maxResults`. | Check the URL you entered. |
| An abort, timeout, or failure occurs after some records are pushed | The records already pushed remain in the dataset; later records are not added. | Use the records already in the dataset and rerun if you need the remaining listings. |
| A category or search URL has more results than the Actor can process in its page loop | The Actor checks up to 200 pagination positions from each starting URL and can return fewer than `maxResults`. | Split the work across additional search URLs where appropriate. |

### FAQ

#### How much does it cost to scrape Aruodas.lt property listings?

See Pricing for the Free-plan event prices and the worked example.

#### Why did my run return an empty dataset?

The Actor only pushes records when it can identify a listing ID, title, and euro price from a listing card. A page with no parsable records, or a page that produces no new unique IDs, stops processing for that URL. Check that the URL is an Aruodas listing or search page.

#### Does this Actor need an Aruodas login or buyer API key?

No Aruodas login is used, and the Actor does not request advertiser contact details. The input consists of Aruodas URLs, a result limit, and Apify Proxy configuration; buyer cookies and external API keys are not part of the input.

#### Is using public Aruodas listing data legal or allowed?

The Actor reads public listing cards that Aruodas serves as HTML. Whether a particular use is legal or allowed depends on the source terms and applicable law for the buyer’s use case; public availability is not a legal guarantee.

### Related actors

- [At Home Japan Rental Listings](https://apify.com/bovi/athome-scraper) — related property-listing extraction for the Japanese market.
- [ChavesNaMão Property Scraper](https://apify.com/bovi/chavesnamao-scraper) — related property scraper.
- [Daft.ie property listings](https://apify.com/bovi/daft-listings) — related property-listing extraction for Ireland.

# Actor input Schema

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

Listing or search pages from aruodas.lt. The default homepage exposes featured listings; category pages can be supplied for filtered results. The Actor follows Aruodas pagination until maxResults is reached.

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

Maximum number of unique property listings to return across all search URLs.

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

Optional Apify Proxy configuration. When disabled or omitted, requests go directly to Aruodas.lt.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.aruodas.lt/"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with the property listing records.

# 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.aruodas.lt/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/aruodas-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 = {
    "searchUrls": ["https://www.aruodas.lt/"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/aruodas-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 '{
  "searchUrls": [
    "https://www.aruodas.lt/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/aruodas-scraper --silent --output-dataset

```

## MCP server setup

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