# Spitogatos Scraper (`automation-lab/spitogatos-property-scraper`) Actor

Extract Greece and Cyprus property sale and rental listings with prices, dimensions, locations, images, agency details, and timestamps.

- **URL**: https://apify.com/automation-lab/spitogatos-property-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (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

Pay per event

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/platform/actors/running/actors-in-store#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

## Spitogatos Scraper

Extract public **Spitogatos** property listings from Greece and Cyprus into a clean Apify Dataset.
The Actor collects sale and rental prices, locations, dimensions, rooms, coordinates, images,
agency details, and publication timestamps for analysis and recurring market monitoring.

It uses Spitogatos geography IDs, so one input can cover Athens Center, all Greece, all Cyprus,
or a custom group of areas. Results are returned in English field names and can be downloaded
as JSON, CSV, Excel, XML, or RSS through Apify.

### What does Spitogatos Scraper do?

The Actor searches Spitogatos's structured property catalog and paginates through matching results.
For each unique listing it creates one normalized dataset row.

You can:

- collect homes for rent or sale;
- search residential, commercial, land, or other property categories;
- filter by price, floor area, bedroom count, and property type;
- cover Greece and Cyprus in the same workflow;
- keep stable listing IDs for comparisons between scheduled runs;
- detect price reductions and listing modification dates;
- export property and agency data to your preferred analysis tool.

This is an unofficial data extraction tool. It is not affiliated with Spitogatos.

### Who is this property data Actor for?

**Real-estate analysts** can build area-level price and availability datasets.

**Property investors** can shortlist listings by budget, size, and location.

**Agencies and proptech teams** can monitor public inventory and compare market activity.

**Researchers and journalists** can study advertised housing supply using reproducible inputs.

**Automation builders** can trigger alerts or downstream enrichment when listing IDs, prices,
or modification timestamps change.

### Why use this Spitogatos extractor?

- **Greece and Cyprus coverage:** area ID `1` represents Greece and `3` represents Cyprus.
- **Useful property fields:** prices, square metres, coordinates, rooms, images, agency, and dates.
- **Pagination and limits:** collect a small sample or thousands of matching listings.
- **Stable monitoring keys:** use `listingId` and `url` to join results from repeated runs.
- **Price-change fields:** retain current price, previous price, and reported reduction percentage.
- **Fail-closed behavior:** exhausted source or proxy errors fail the run instead of returning a
  misleading successful empty dataset.
- **Efficient HTTP extraction:** the Actor does not download listing images or launch a browser.

### What Spitogatos data can I extract?

| Field | Description |
| --- | --- |
| `listingId`, `url` | Stable listing ID and public property URL |
| `listingType` | `rent` or `sale` |
| `category`, `propertySubtype` | Source category and subtype code |
| `price`, `previousPrice` | Current and previous advertised price in EUR |
| `priceReduced`, `priceChangePercent` | Source price-reduction indicators |
| `areaSqm`, `pricePerSqm` | Floor area and calculated EUR per m² |
| `location` | Human-readable Spitogatos geography |
| `latitude`, `longitude`, `geocodeType` | Published map position and precision |
| `bedrooms`, `bathrooms` | Room counts when available |
| `kitchens`, `livingRooms`, `floor` | Additional dimensions and floor code |
| `description` | Public listing description |
| `mainImageUrl`, `imageUrls` | Main image and gallery image URLs |
| `hasVirtualTour`, `hasVideo` | Media availability flags |
| `isNewDevelopment`, `listingTier` | Development and promotion metadata |
| `agency` | Agency ID, name, profile, logo, and membership |
| `uploadedAt`, `modifiedAt`, `firstPublishedAt` | Source timestamps |
| `scrapedAt` | Collection timestamp in ISO 8601 format |

Source fields can be missing. Nullable output fields are returned as `null`, while media arrays can
be empty.

### How to scrape Spitogatos listings

1. Open the Actor in Apify Console.
2. Enter one or more **Area IDs**.
3. Select `rent` or `sale`.
4. Choose a property category.
5. Add optional price, area, bedroom, or property-type filters.
6. Set the maximum number of listings.
7. Keep the default Residential proxy configuration.
8. Click **Start**.
9. Open the Dataset tab to preview or export the results.

A useful first run is Athens Center rentals:

```json
{
  "areaIds": ["100"],
  "listingType": "rent",
  "category": "residential",
  "priceMax": 1200,
  "maxItems": 20
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `areaIds` | string array | `["100"]` | Spitogatos geography IDs; `1` Greece, `3` Cyprus, `100` Athens Center |
| `listingType` | string | `rent` | `rent` or `sale` |
| `category` | string | `residential` | `residential`, `commercial`, `land`, or `other` |
| `propertyTypes` | string array | none | Optional source type codes such as `apartment` or `detached` |
| `priceMin` | integer | none | Minimum monthly rent or sale price in EUR |
| `priceMax` | integer | none | Maximum monthly rent or sale price in EUR |
| `areaMin` | integer | none | Minimum floor area in m² |
| `areaMax` | integer | none | Maximum floor area in m² |
| `bedroomsMin` | integer | none | Minimum reported bedrooms or rooms |
| `bedroomsMax` | integer | none | Maximum reported bedrooms or rooms |
| `maxItems` | integer | `100` | Maximum unique rows, from 1 to 10,000 |
| `proxyConfiguration` | object | Residential, Greece | Apify Proxy configuration |

Area IDs are strings in the Console editor but are validated as positive integers before any request.
Invalid ranges, unsupported categories, and malformed limits fail immediately.

### Greece, Athens, and Cyprus examples

All Greece residential homes for sale:

```json
{
  "areaIds": ["1"],
  "listingType": "sale",
  "category": "residential",
  "maxItems": 100
}
```

Athens Center rentals under €1,200:

```json
{
  "areaIds": ["100"],
  "listingType": "rent",
  "category": "residential",
  "priceMax": 1200,
  "maxItems": 100
}
```

Cyprus sale listings of at least 70 m²:

```json
{
  "areaIds": ["3"],
  "listingType": "sale",
  "category": "residential",
  "areaMin": 70,
  "maxItems": 100
}
```

### Output example

The following shortened record reflects the current output contract; the agency name is anonymized.

```json
{
  "listingId": 12345678,
  "url": "https://www.spitogatos.gr/en/property/12345678",
  "listingType": "rent",
  "category": "house",
  "price": 690,
  "previousPrice": 750,
  "priceReduced": true,
  "priceChangePercent": 8,
  "currency": "EUR",
  "areaSqm": 73,
  "pricePerSqm": 9.45,
  "location": "Athens Center (Attica)",
  "latitude": 37.97,
  "longitude": 23.73,
  "bedrooms": 2,
  "bathrooms": 1,
  "mainImageUrl": "https://m2.spitogatos.gr/123456_300x220.jpg",
  "imageUrls": ["https://m2.spitogatos.gr/123456_1280x960.jpg"],
  "agency": {
    "id": 1234,
    "name": "Example Realty",
    "profileUrl": "https://www.spitogatos.gr/agents/example-realty/1234",
    "logoUrl": null,
    "membership": "expert"
  },
  "modifiedAt": "2025-01-16 09:30:00",
  "scrapedAt": "2025-01-16T10:00:00.000Z"
}
```

### How much does it cost to extract Spitogatos property listings?

Pricing is pay per event: one small `start` event per run and one `item` event per saved listing.
The active FREE-tier prices are **$0.00005 per start** and **$0.00184 per property listing**.
Paid Apify plans receive the tier price shown in Console; BRONZE is $0.00160 per listing.

Examples at the FREE tier:

| Listings | Start | Listing events | Total Actor charge |
| ---: | ---: | ---: | ---: |
| 10 | $0.00005 | $0.01840 | about $0.01845 |
| 100 | $0.00005 | $0.18400 | about $0.18405 |
| 1,000 | $0.00005 | $1.84000 | about $1.84005 |

The Actor charges only normalized rows saved to the dataset. Duplicate, rejected, failed, or empty
records do not create item charges. Check the live pricing panel because Apify plan tiers can differ.

### Monitoring new and changed listings

Schedule the same Task daily or hourly and store each resulting dataset.
Use `listingId` as the stable join key.
Compare:

- IDs absent from the previous run to find newly observed listings;
- `price` and `previousPrice` to identify price changes;
- `modifiedAt` to prioritize recently updated ads;
- IDs missing from the new sample only with care, because filters, ordering, and `maxItems` can also
  change which listings appear.

For complete comparisons, keep filters and limits consistent between runs.

### Export to CSV, Excel, or a data pipeline

Open the run's Dataset and choose JSON, CSV, Excel, XML, or RSS.
You can also send the dataset to Google Sheets, Make, Zapier, n8n, a database, or an internal API.

Typical workflows include:

1. schedule the Actor;
2. fetch rows by dataset API;
3. upsert by `listingId`;
4. compare price and timestamps;
5. notify an analyst when a rule matches.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~spitogatos-property-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "areaIds": ["100"],
    "listingType": "rent",
    "category": "residential",
    "priceMax": 1200,
    "maxItems": 20
  }'
```

Fetch results using the `defaultDatasetId` returned by the run:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=$APIFY_TOKEN&format=json"
```

### Run from JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/spitogatos-property-scraper').call({
  areaIds: ['3'],
  listingType: 'sale',
  category: 'residential',
  areaMin: 70,
  maxItems: 100,
});

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

### Run from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/spitogatos-property-scraper').call(run_input={
    'areaIds': ['1'],
    'listingType': 'sale',
    'category': 'residential',
    'maxItems': 100,
})

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

### Use Spitogatos Scraper with Apify MCP

#### Claude Code setup

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/spitogatos-property-scraper"
```

#### Claude Desktop setup

Add this server to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/spitogatos-property-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers.apify.url` value in **Cursor Settings → MCP**.

#### VS Code setup

Add the same HTTP MCP URL to your VS Code MCP server configuration.

Example prompts:

- “Extract 20 Athens Center rentals below €1,200 and summarize median price per m².”
- “Collect 50 Cyprus homes for sale over 70 m² and save the dataset.”
- “Run my saved Spitogatos monitoring input and compare IDs and prices with yesterday.”

### Limits and responsible operation

Spitogatos protects its public catalog, so Residential proxy access is required.
The default makes structured requests through Apify Residential proxies in Greece.
Disabling proxy access or using blocked datacenter addresses can cause the run to fail.

The source returns up to 30 records per page. Results are deduplicated by listing ID and stop at
`maxItems` or the final source page.

Source taxonomy, availability, image URLs, descriptions, and timestamps can change.
Coordinates may be approximate; check `geocodeType` before location-sensitive decisions.
The Actor does not contact agencies, download images, value properties, or guarantee that an ad
is still available after extraction.

### Troubleshooting

**The run says a proxy is required.**
Enable Apify Proxy and include the `RESIDENTIAL` group. The default input already does this.

**The run failed after three sessions.**
The source challenged or temporarily rejected every bounded retry. Wait before retrying rather than
launching many immediate runs. If the problem persists, share the run URL with support.

**I received zero listings.**
Confirm the area IDs and relax narrow price, area, bedroom, or property-type filters. A successful
zero-row response is possible when the selected source query has no current matches.

**Why is a field null?**
Sellers and agencies do not publish every attribute. Nullability reflects the public source record.

**Why does an image URL stop working?**
Spitogatos controls its image CDN and can move or remove media after the dataset is created.

### Is scraping Spitogatos legal?

This Actor extracts publicly accessible listing information. Laws, website terms, database rights,
and privacy obligations vary by jurisdiction and use case. You are responsible for having a lawful
purpose, respecting applicable terms, limiting collection to what you need, and handling personal
or agency information appropriately. Do not use the Actor for harassment, discrimination, spam,
or decisions that require verified property or identity information.

### Frequently asked questions

**Does it support Spitogatos English data?**
Output keys are English and location text is returned by the source locale used by the API.
Descriptions may remain in the language supplied by the publisher.

**Can it scrape Athens?**
Yes. Use area ID `100` for Athens Center or another known Spitogatos geography ID.

**Can it scrape Cyprus?**
Yes. Use area ID `3` for all Cyprus, then apply price, size, bedroom, or category filters.

**Can I collect commercial property or land?**
Yes. Set `category` to `commercial` or `land`.

**Can I run it on a schedule?**
Yes. Create an Apify Task, keep its input stable, and add a schedule.

**Does it provide an official Spitogatos API?**
No. It is an independent Actor that turns public catalog responses into a normalized Apify Dataset.

**Does it charge for failed rows?**
No. The listing event is charged only for normalized records saved to the default dataset.

### Related automation-lab Actors

Combine this Actor with other `automation-lab` real-estate and location tools in Apify Store when
you need a broader workflow. Search the automation-lab profile for currently available related
Actors; this README intentionally avoids linking unsupported or unpublished products.

# Actor input Schema

## `areaIds` (type: `array`):

Spitogatos geography IDs. Use 1 for all Greece, 3 for all Cyprus, or 100 for Athens Center. Multiple IDs can be combined.

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

Choose properties offered for rent or sale.

## `category` (type: `string`):

Select the broad property category to search.

## `propertyTypes` (type: `array`):

Optional Spitogatos property type codes, such as apartment or detached.

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

Only return listings at or above this monthly rent or sale price.

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

Only return listings at or below this monthly rent or sale price.

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

Minimum property floor area in square metres.

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

Maximum property floor area in square metres.

## `bedroomsMin` (type: `integer`):

Minimum number of bedrooms or rooms reported by Spitogatos.

## `bedroomsMax` (type: `integer`):

Maximum number of bedrooms or rooms reported by Spitogatos.

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

Stop after saving this many unique property listings.

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

Residential proxy access is required by Spitogatos. The default uses Apify Residential proxies in Greece.

## Actor input object example

```json
{
  "areaIds": [
    "100"
  ],
  "listingType": "rent",
  "category": "residential",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All property records collected during this run.

# 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 = {
    "areaIds": [
        "100"
    ],
    "listingType": "rent",
    "category": "residential",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/spitogatos-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 = {
    "areaIds": ["100"],
    "listingType": "rent",
    "category": "residential",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/spitogatos-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 '{
  "areaIds": [
    "100"
  ],
  "listingType": "rent",
  "category": "residential",
  "maxItems": 20
}' |
apify call automation-lab/spitogatos-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/spitogatos-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/7Vl3TvQESUhNSYAXA/builds/2rLdB4MsEYr3jITOf/openapi.json