# Spitogatos Scraper - Greece & Cyprus Real Estate API (`swerve/spitogatos-scraper`) Actor

Scrape real estate listings from Spitogatos.gr, Greece's largest property platform. Rent & buy across 20,000+ areas. Returns prices, photos, location, rooms, agent info, and optional enrichment with phone numbers, amenities, and descriptions.

- **URL**: https://apify.com/swerve/spitogatos-scraper.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** AI, Real estate, Lead generation
- **Stats:** 8 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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.gr Real Estate Scraper - Greece & Cyprus

Scrape real estate listings from [Spitogatos.gr](https://www.spitogatos.gr), Greece's #1 property platform with 100,000+ active listings across 20,000+ geographic areas.

### Features

- **Rent & Sale** - scrape residential, commercial, or land listings
- **All of Greece + Cyprus** - search by city, region, island, or neighborhood
- **Rich data** - price, area, rooms, bathrooms, floor, GPS coordinates, images, agent info
- **Optional enrichment** - phone numbers, full descriptions, 20+ amenities (elevator, AC, parking, balcony, pool, etc.), energy class, year built
- **Server-side filters** - price range, area range, room count
- **Fast** - uses Spitogatos's internal API, no browser needed for basic scraping
- **Pagination** - handles 300 listings per page automatically

### Use Cases

- **Airbnb and short-term rental investors** finding sale properties in Mykonos, Santorini, and Paros with pool, view, and parking to convert into vacation rentals
- **Golden Visa advisors** helping non-EU clients find qualifying Greek properties (€250k+) with verified location and energy class data
- **Relocation services** matching remote workers and digital nomads to apartments in Athens, Thessaloniki, and Limassol with specific amenity filters
- **Real estate agencies** monitoring competitor listings, price reductions, and new developments across Greece and Cyprus
- **Market analysts** tracking price per sqm trends by neighbourhood (Kolonaki, Glyfada, Piraeus) and energy class distributions for ESG-focused funds
- **PropTech startups** building Greek-market AVMs and price comparison tools on top of Spitogatos's 100k+ listing inventory

### Output Fields

#### Core Fields (always available)

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | number | Unique Spitogatos listing ID |
| `url` | string | Direct link to the listing |
| `listingType` | string | `rent` or `sale` |
| `propertyType` | string | `apartment`, `house`, `maisonette`, `studio`, etc. |
| `price` | number | Asking price in EUR |
| `pricePerSqm` | number | Price per square meter |
| `priceReduced` | boolean | Whether the price was recently reduced |
| `previousPrice` | number | Previous price before reduction (if applicable) |
| `areaSqm` | number | Living area in square meters |
| `rooms` | number | Number of rooms |
| `bathrooms` | number | Number of bathrooms |
| `kitchens` | number | Number of kitchens |
| `livingRooms` | number | Number of living rooms |
| `floor` | number | Floor number |
| `location` | string | Neighborhood and city (e.g. "Plaka (Athens - Center)") |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `images` | string[] | Array of high-resolution image URLs (up to 30) |
| `hasVirtualTour` | boolean | Whether listing has a virtual tour |
| `hasVideo` | boolean | Whether listing has a video |
| `agentName` | string | Real estate agent or agency name |
| `agentId` | number | Agent ID on Spitogatos |
| `isNewDevelopment` | boolean | Whether it's a new construction project |
| `uploadedAt` | string | When the listing was first uploaded |
| `modifiedAt` | string | When the listing was last modified |
| `firstPublishedAt` | string | When the listing was first published |

#### Enriched Fields (available when `enrichListings` is enabled)

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full property description |
| `contactPhone` | string | Phone number (e.g. "+302110014573") |
| `contactName` | string | Contact person name |
| `agentWebsite` | string | Agent's website URL |
| `yearBuilt` | number | Year of construction |
| `renovationYear` | number | Year of last renovation |
| `energyClass` | string | Energy efficiency class (A+ to H) |
| `elevator` | boolean | Has elevator |
| `airConditioning` | boolean | Has AC |
| `fireplace` | boolean | Has fireplace |
| `storage` | boolean | Has storage room |
| `balcony` | boolean | Has balcony |
| `garden` | boolean | Has garden |
| `pool` | boolean | Has swimming pool |
| `hasParking` | boolean | Has parking |
| `openParkingSpots` | number | Number of open parking spots |
| `closedParkingSpots` | number | Number of garage/closed spots |
| `alarm` | boolean | Has alarm system |
| `furnished` | string | Furnishing status |
| `petsAllowed` | boolean | Pets allowed |
| `view` | boolean | Has view |
| `solarHeater` | boolean | Has solar water heater |

### Example Input

```json
{
  "location": "Athens",
  "listingType": "rent",
  "propertyCategory": "residential",
  "maxItems": 200,
  "minPrice": 400,
  "maxPrice": 1000,
  "enrichListings": true
}
````

### Supported Locations

Search by any Greek city, region, island, or neighborhood. Examples:

- Cities: `Athens`, `Thessaloniki`, `Heraklion`, `Patras`, `Larissa`
- Regions: `Attica`, `Crete`, `Peloponnese`, `Thessaly`
- Islands: `Mykonos`, `Santorini`, `Rhodes`, `Corfu`, `Paros`
- Neighborhoods: `Plaka`, `Kolonaki`, `Glyfada`, `Kifisia`, `Piraeus`
- Cyprus: `Limassol`, `Nicosia`, `Paphos`, `Larnaca`

### Pricing Note

- **Basic mode** (enrichment off): Fast, lightweight - uses API directly
- **Enrichment mode**: Uses a headless browser for initial cookie acquisition, then API calls for details. Adds ~0.5s per listing but returns phone numbers, descriptions, and all amenities.

### Other Scrapers by Swerve

- [Yad2 Scraper](https://apify.com/swerve/yad2-scraper) - Israel's #1 classifieds
- [Madlan Scraper](https://apify.com/swerve/madlan-scraper) - Israeli real estate listings
- [Madlan Analytics](https://apify.com/swerve/madlan-analytics) - Market data, schools, reviews, deals
- [Madlan Deal Analyzer](https://apify.com/swerve/madlan-deal-analyzer) - Find underpriced properties
- [Homeless.co.il Scraper](https://apify.com/swerve/homeless-scraper) - Israeli classifieds

### Keywords

Spitogatos scraper, Greek real estate API, Greece property listings, Athens apartments data, Mykonos villas scraper, Santorini real estate, Cyprus property data, Golden Visa Greece, spitogatos.gr scraper, Thessaloniki apartments, Greek islands real estate, Limassol property listings

# Actor input Schema

## `location` (type: `string`):

City, region, or area name (e.g. 'Athens', 'Thessaloniki', 'Crete', 'Mykonos', 'Glyfada'). The scraper will auto-match to the closest Spitogatos area.

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

Rent or sale listings

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

Type of property

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

Maximum number of listings to return.

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

Minimum price filter in EUR (optional)

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

Maximum price filter in EUR (optional)

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

Minimum area in square meters (optional)

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

Maximum area in square meters (optional)

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

Minimum number of rooms (optional)

## `maxRooms` (type: `integer`):

Maximum number of rooms (optional)

## `publishedAfter` (type: `string`):

Only include listings first published on or after this date. Dramatically reduces cost for daily monitoring / delta scraping. Accepts ISO (YYYY-MM-DD) or d/m/Y.

## `modifiedAfter` (type: `string`):

Only include listings whose agent modified them on or after this date. Applied as a client-side filter after fetch, so it does NOT reduce credit cost (use 'Published After' for cost savings).

## `enrichListings` (type: `boolean`):

BETA: Fetch additional details for each listing (description, phone numbers, amenities). Requires solving Spitogatos's bot protection - may not work on all listings. Without this, enrichment fields will be null but core data (price, area, rooms, location, images, agent) is always available.

## Actor input object example

```json
{
  "location": "Athens",
  "listingType": "rent",
  "propertyCategory": "residential",
  "maxItems": 200,
  "enrichListings": false
}
```

# 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 = {
    "location": "Athens"
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/spitogatos-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 = { "location": "Athens" }

# Run the Actor and wait for it to finish
run = client.actor("swerve/spitogatos-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "location": "Athens"
}' |
apify call swerve/spitogatos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=swerve/spitogatos-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spitogatos Scraper - Greece & Cyprus Real Estate API",
        "description": "Scrape real estate listings from Spitogatos.gr, Greece's largest property platform. Rent & buy across 20,000+ areas. Returns prices, photos, location, rooms, agent info, and optional enrichment with phone numbers, amenities, and descriptions.",
        "version": "1.0",
        "x-build-id": "vnUf8zedq5bKiR8G4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swerve~spitogatos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swerve-spitogatos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/swerve~spitogatos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-swerve-spitogatos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/swerve~spitogatos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-swerve-spitogatos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or area name (e.g. 'Athens', 'Thessaloniki', 'Crete', 'Mykonos', 'Glyfada'). The scraper will auto-match to the closest Spitogatos area."
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "rent",
                            "sale"
                        ],
                        "type": "string",
                        "description": "Rent or sale listings",
                        "default": "rent"
                    },
                    "propertyCategory": {
                        "title": "Property Category",
                        "enum": [
                            "residential",
                            "commercial",
                            "land"
                        ],
                        "type": "string",
                        "description": "Type of property",
                        "default": "residential"
                    },
                    "maxItems": {
                        "title": "Max Listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 200
                    },
                    "minPrice": {
                        "title": "Min Price (€)",
                        "type": "integer",
                        "description": "Minimum price filter in EUR (optional)"
                    },
                    "maxPrice": {
                        "title": "Max Price (€)",
                        "type": "integer",
                        "description": "Maximum price filter in EUR (optional)"
                    },
                    "minArea": {
                        "title": "Min Area (sqm)",
                        "type": "integer",
                        "description": "Minimum area in square meters (optional)"
                    },
                    "maxArea": {
                        "title": "Max Area (sqm)",
                        "type": "integer",
                        "description": "Maximum area in square meters (optional)"
                    },
                    "minRooms": {
                        "title": "Min Rooms",
                        "type": "integer",
                        "description": "Minimum number of rooms (optional)"
                    },
                    "maxRooms": {
                        "title": "Max Rooms",
                        "type": "integer",
                        "description": "Maximum number of rooms (optional)"
                    },
                    "publishedAfter": {
                        "title": "Published After",
                        "type": "string",
                        "description": "Only include listings first published on or after this date. Dramatically reduces cost for daily monitoring / delta scraping. Accepts ISO (YYYY-MM-DD) or d/m/Y."
                    },
                    "modifiedAfter": {
                        "title": "Modified After",
                        "type": "string",
                        "description": "Only include listings whose agent modified them on or after this date. Applied as a client-side filter after fetch, so it does NOT reduce credit cost (use 'Published After' for cost savings)."
                    },
                    "enrichListings": {
                        "title": "Enrich Listings (Beta)",
                        "type": "boolean",
                        "description": "BETA: Fetch additional details for each listing (description, phone numbers, amenities). Requires solving Spitogatos's bot protection - may not work on all listings. Without this, enrichment fields will be null but core data (price, area, rooms, location, images, agent) is always available.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
