# Spitogatos Scraper - Greece Real Estate Data (`benthepythondev/spitogatos-scraper`) Actor

Scrape Spitogatos.gr (Greece's #1 property portal), for sale or to rent: price, size (m2), rooms, bathrooms, floor, location, coordinates, photos, agency name and listing URL. Paste any Spitogatos search URL.

- **URL**: https://apify.com/benthepythondev/spitogatos-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Real estate, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/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 Scraper - Greece Real Estate & Agent Data

Scrape **Spitogatos.gr**, Greece's largest real-estate marketplace, into structured property data. The actor returns sale and rental listings with price, area, rooms, bathrooms, floor, coordinates, photos, listing URL, agency name and other useful property fields.

### What does this actor do?

Spitogatos is one of the main places where buyers, renters, investors and agencies monitor Greek property supply. It covers apartments, houses, land and residential listings across Athens, Thessaloniki, islands and regional markets. This actor turns Spitogatos search pages into clean datasets that can be exported to JSON, CSV, Excel or pulled through the Apify API.

The site is protected by a real browser challenge, so this actor uses a stealth browser with Greek residential proxy support. It loads the public search page, captures Spitogatos' own search API response from inside the cleared browser session, then paginates the internal JSON endpoint. That gives cleaner data than visual HTML scraping.

### Input

Use `searchUrls` to paste one or more Spitogatos search result URLs. Open Spitogatos, apply filters such as sale/rent, area, property type or price range, then paste the URL.

Use `maxResults` to control how many listings are returned per search URL. Keep small values for quick tests and larger values for production collection.

### Output fields

Each property listing can include:

- `id`
- `url`
- `listing_type` - sale or rent
- `property_type`
- `subtype`
- `price`
- `currency`
- `price_period`
- `price_reduced`
- `area_m2`
- `bedrooms`
- `total_rooms`
- `bathrooms`
- `kitchens`
- `living_rooms`
- `floor`
- `area`
- `latitude` and `longitude`
- `description`
- `image`
- `num_images`
- `has_virtual_tour`
- `has_video`
- `agent_id`
- `agency_name`
- `uploaded`
- `modified`
- `first_publish_date`
- `search`

### Use cases

Use this actor for Greek real-estate market research, agency lead generation, investor sourcing, pricing analysis, property-alert workflows, rental-market tracking, supply monitoring and geospatial analysis.

#### Agency lead generation

Professional listings often include the agency name and agent id. You can use those fields to identify active agencies in a city or property segment, then enrich the agency with contact data in a second step.

#### Investor monitoring

Investors can run focused searches for areas, price bands or property types. The output includes price, area, room count and coordinates, making it suitable for spreadsheet scoring or map-based review.

#### Market snapshots

Because the actor captures Spitogatos' own listing data, it is useful for recurring snapshots. Run the same search weekly and track price changes, newly uploaded listings, photos, geographies and agency activity.

#### Rental and sale workflows

The actor supports both sale and rental search URLs. Rental listings include `price_period` when detected, while sale listings return price as a normal EUR amount.

### Reliability notes

Spitogatos uses Imperva protection, so a simple HTTP request is not enough. This actor uses Camoufox and Apify residential Greek proxies to behave like a normal browser and capture the site's own JSON response.

The default input is intentionally small enough for daily auto-tests. For production collection, use specific filtered URLs rather than broad nationwide searches. That makes runs faster and produces cleaner segmented datasets.

Because protected sites can change, the actor is designed around the network API response rather than fragile CSS selectors. If Spitogatos changes its internal endpoint, the actor logs enough context to diagnose the issue.

### Pricing

This actor uses pay-per-result pricing. You are charged for each property listing pushed to the dataset, plus a tiny actor-start event. Browser/proxy work is handled inside the actor; keep tests small to avoid unnecessary usage.

### FAQ

#### Does this actor require a Spitogatos account?

No. It reads public search result data and does not log in.

#### Does it work from Apify?

Yes. It has been live-tested on Apify with Greek residential proxy support and returned real property listings.

#### Can I scrape Athens or Thessaloniki only?

Yes. Apply the area filter on Spitogatos and paste that search URL into `searchUrls`.

#### Does it return agency data?

When Spitogatos exposes professional listing data, the actor returns agency and agent identifiers such as `agency_name` and `agent_id`.

#### Why does it use a browser?

Spitogatos serves an anti-bot challenge to plain HTTP clients. The browser engine is required for reliable collection.

### You might also like

- Idealista Scraper - Spain real-estate listings
- Immobiliare Scraper - Italy real-estate listings
- Funda Scraper - Netherlands property listings
- Website Contact Extractor - enrich agency websites with emails and phones

### Keywords

Spitogatos scraper, Greece real estate scraper, Greek property data, Athens property listings, Thessaloniki real estate, Greece rental scraper, property agency leads, Greek housing market data, Spitogatos API, real estate lead generation.

# Actor input Schema

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

Paste Spitogatos.gr search-results URLs (homes/apartments for sale or to rent, any area or filter). Copy the URL from your browser after searching on spitogatos.gr. Leave empty for homes for sale across Greece.
## `maxResults` (type: `integer`):

Maximum number of listings to return per search URL.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.spitogatos.gr/en/for_sale-homes/greece"
  ],
  "maxResults": 10
}
````

# 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.spitogatos.gr/en/for_sale-homes/greece"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "searchUrls": ["https://www.spitogatos.gr/en/for_sale-homes/greece"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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 '{
  "searchUrls": [
    "https://www.spitogatos.gr/en/for_sale-homes/greece"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/spitogatos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spitogatos Scraper - Greece Real Estate Data",
        "description": "Scrape Spitogatos.gr (Greece's #1 property portal), for sale or to rent: price, size (m2), rooms, bathrooms, floor, location, coordinates, photos, agency name and listing URL. Paste any Spitogatos search URL.",
        "version": "1.0",
        "x-build-id": "sufZ0r08UWXN6kCUb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~spitogatos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~spitogatos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~spitogatos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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",
                "properties": {
                    "searchUrls": {
                        "title": "Spitogatos search URLs",
                        "type": "array",
                        "description": "Paste Spitogatos.gr search-results URLs (homes/apartments for sale or to rent, any area or filter). Copy the URL from your browser after searching on spitogatos.gr. Leave empty for homes for sale across Greece.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of listings to return per search URL.",
                        "default": 40
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
