# Spitogatos.gr Scraper: Greek Real Estate Listings (`dltik/spitogatos-scraper`) Actor

Scrape Spitogatos.gr, Greece's largest property marketplace. Sale & rent listings nationwide: price, price/m², area, rooms, floor, year, GPS, energy class, agent phone, photos. Filter, sort by newest/price, price-drops-only, new-builds-only, phone-only leads. Residential proxy included. Optional AI.

- **URL**: https://apify.com/dltik/spitogatos-scraper.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:** Real estate, Business, Lead generation
- **Features:** Limited permissions
- **Stats:** 13 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing scrapeds

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

## Spitogatos.gr Scraper — Greek Real Estate Listings

> ⭐ **Bookmark this actor** (button, top-right) — it's the #1 signal that keeps it maintained and visible. One click.

Scrape property listings from **Spitogatos.gr**, Greece's largest real-estate marketplace, for **sale and rent** across the whole country. This Spitogatos scraper returns clean, structured data for every listing — price, price per m², area, rooms, floor, build year, energy class, GPS coordinates, agent/owner name and phone, and photos — ready for CSV, Excel, JSON or API.

Built for real-estate agencies, investors, proptech and market-research teams that need Greek property data at scale without maintaining a scraper.

### What Spitogatos.gr Scraper does

- **Both markets**: for-sale (πωλήσεις) and for-rent (ενοικιάσεις) listings.
- **All property classes**: homes (apartments & houses), commercial, land, parking.
- **Nationwide**: search any area, city or neighborhood — Athens, Thessaloniki, the islands, anywhere Spitogatos covers.
- **Rich fields per listing**: title, price, **price per m²**, living area, rooms, bathrooms, floor, **year built**, **energy class**, region/city/neighborhood, **latitude/longitude**, agent/owner name and **phone number**, all photo URLs, and the canonical listing URL.
- **Two ways to target data**: paste search or listing URLs straight from the site, or use structured filters (transaction, category, location, price, area, rooms, bathrooms, energy class).
- **Sorting**: newest first, or price low→high / high→low — applied before the result cap, so you grab exactly the slice you want.
- **Deal & lead filters**:
  - **Price drops only** — surface listings whose asking price was just reduced (motivated sellers); each record also gets `price_before_reduction`.
  - **New builds only** — new-development properties.
  - **Posted within N days** — monitor fresh inventory daily/weekly.
  - **Phone only** — return only listings that expose a contact phone (lead generation).
- **Optional deep detail**: turn on *Fetch full detail per listing* to also pull the full description, street address, complete photo set and agent phone.
- **Optional AI analysis** (premium): translate the Greek description to an English summary + highlights, infer condition/view/furnished/Airbnb potential, and — with an investor profile — score each listing (deal score, estimated yield, buy/watch/skip).

### How to use it

You can drive the scraper two ways.

#### 1. Paste URLs (easiest)

Build the exact search you want on spitogatos.gr, copy the URL, and paste it into **Start URLs**. Both search pages and single-property pages work:

```
https://www.spitogatos.gr/en/for_sale-homes/athens-center
https://www.spitogatos.gr/en/to_rent-homes/thessaloniki
https://www.spitogatos.gr/en/property/1112975761
```

#### 2. Structured filters

Leave Start URLs empty and set:

| Field | Example |
|---|---|
| Transaction | `buy` (sale) / `rent` |
| Property category | `homes`, `commercial`, `land`, `parking` |
| Location(s) | `Athens - Center`, `Glyfada`, `Thessaloniki` |
| Min/Max price (€) | `100000` – `300000` |
| Min/Max area (m²) | `60` – `120` |
| Min / Max rooms | `2` / `4` |
| Min bathrooms | `1` |
| Energy class | `["A+","A","B"]` |
| Sort by | `newest`, `price_asc`, `price_desc` |
| Price drops only | `true` |
| New builds only | `true` |
| Posted within (days) | `7` |
| Phone only (leads) | `true` |
| Max results | `100` |

Location names are resolved to Spitogatos' internal area IDs automatically. If a name doesn't resolve, paste the search URL into Start URLs instead, or supply **Area IDs** directly.

### Example input

```json
{
  "transaction": "buy",
  "propertyType": "homes",
  "locationQuery": ["Athens - Center"],
  "priceMax": 400000,
  "areaMin": 60,
  "maxResults": 100,
  "fetchDetails": true
}
```

### Example output

```json
{
  "source": "spitogatos",
  "source_id": "12975761",
  "url": "https://www.spitogatos.gr/en/property/1112975761",
  "transaction": "buy",
  "property_type": "apartment",
  "title": "Apartment 120m² in Kolonaki",
  "price": 456000,
  "price_currency": "EUR",
  "price_per_m2": 3800,
  "price_reduced": true,
  "price_before_reduction": 480000,
  "surface": 120,
  "rooms": 3,
  "bathrooms": 2,
  "floor": "2",
  "year_built": 2005,
  "region": "Attica",
  "city": "Athens",
  "neighborhood": "Kolonaki",
  "address": "…",
  "latitude": 37.9795,
  "longitude": 23.7448,
  "energy_class": "A",
  "is_new_build": false,
  "has_video": true,
  "has_virtual_tour": false,
  "contact_name": "…",
  "contact_phone": "+30…",
  "photo_count": 24,
  "main_photo_url": "https://…",
  "photos": ["https://…"]
}
```

### Proxy — included, nothing to configure

Spitogatos.gr is protected by **Imperva** bot management (the *"Pardon Our Interruption"* challenge), which requires a clean **residential** IP. **A residential proxy is bundled with this actor** — you don't need to bring your own or configure anything. Just run it and you get data.

The actor clears the Imperva challenge once with a real browser step, then pulls all data over the fast internal API, so runs stay quick — and the cleared session is **cached across runs**, so repeat runs skip the browser step entirely and finish even faster.

Advanced users can still plug their **own** residential/mobile pool via **Custom proxy URL** (optional) — it simply overrides the included proxy.

### Pricing

Pay-per-result: **$0.005 per listing** ($5 / 1,000 listings). You are charged only for listings actually delivered. The optional detail fetch (description, address, phone, all photos) is included in the same per-listing price — no surprise extra charge. Start with a small `maxResults` (e.g. 20) to validate the output before scaling up.

Optional **AI analysis** is a separate **$0.01 per analyzed listing**, charged on top of `listing-scraped` only when `analyzeListings` is on (paid Apify plans).

### AI analysis (premium)

Enable `analyzeListings` to add an `ai` object to every record. Without a profile it translates and structures the Greek listing; add an `investorProfile` (e.g. *"Golden-visa buyer, 300k budget, Airbnb income in central Athens"*) to also rank listings:

```json
"ai": {
  "summary_en": "Fully renovated 58m² flat with Acropolis view, furnished, near metro.",
  "highlights": ["Acropolis view", "Renovated", "Furnished", "Near metro"],
  "condition": "renovated",
  "view": "Acropolis view",
  "furnished": true,
  "airbnb_potential": "high",
  "deal_score": 78,
  "estimated_gross_yield_pct": 4.5,
  "flags": ["priced slightly above area avg"],
  "recommended_action": "buy",
  "fit_reason": "Central, Airbnb-ready, fits golden-visa goal."
}
```

Tip: enable *Fetch full detail* too, so the AI reads the full description.

### FAQ

**Is scraping Spitogatos legal?** The actor collects publicly available listing data. You are responsible for using the data in line with Spitogatos' terms and applicable law (including GDPR for any personal/agent contact data).

**Why do I get 0 results?** The residential proxy is included, so it's usually the search itself: check the location spelling (or paste an exact spitogatos.gr search URL into Start URLs) and loosen any strict price/area/energy filters.

**Can I get the agent's phone number?** Yes — the phone comes from the listing's publisher and is included; enable *Fetch full detail per listing* to guarantee it on every record.

**Which languages?** Field values come straight from Spitogatos (Greek for free-text like description/address); all structured fields (price, area, GPS, energy class, etc.) are language-independent.

**Can I schedule it?** Yes — use Apify Schedules to run daily/weekly and monitor new listings in an area.

***

⭐ If this saved you time, **bookmark the actor** — it's the single biggest thing that helps others find it.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Spitogatos.gr search-result URLs (e.g. https://www.spitogatos.gr/en/for_sale-homes/athens-center) or single property URLs. This is the most reliable way to target exactly what you see in the browser — build the search on the site, copy the URL, paste it here. When set, the structured filters below are ignored. Leave empty to use the filters instead.

## `transaction` (type: `string`):

buy = for sale (πωλήσεις), rent = for rent (ενοικιάσεις). Used only when Start URLs is empty.

## `propertyType` (type: `string`):

Which kind of property to search. Used only when Start URLs is empty.

## `locationQuery` (type: `array`):

Area / city / neighborhood names as they appear on Spitogatos (e.g. \['Athens - Center','Thessaloniki','Glyfada']). Each name is resolved to Spitogatos' internal area ID and searched. Used only when Start URLs is empty. Tip: if a name doesn't resolve, paste the search URL into Start URLs instead, or use Area IDs below.

## `areaIDs` (type: `array`):

Spitogatos internal geography IDs (integers), e.g. \[100, 104]. Skips name resolution — use this when you already know the IDs (from the site's network calls) for an exact match. Used only when Start URLs is empty.

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

Minimum listing price in euros.

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

Maximum listing price in euros.

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

Minimum living area in m².

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

Maximum living area in m².

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

Minimum number of rooms (bedrooms).

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

Maximum number of rooms (bedrooms).

## `bathroomsMin` (type: `integer`):

Keep only listings with at least this many bathrooms.

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

Order results before the Max results cap is applied — useful to grab the newest or cheapest first. 'Relevance' is Spitogatos' default ranking.

## `priceDropsOnly` (type: `boolean`):

Return only listings whose asking price was recently reduced (price_reduced = true). Great for spotting motivated sellers and deals. Adds price_before_reduction to each record.

## `newBuildOnly` (type: `boolean`):

Return only new-development / newly-built properties.

## `energyClass` (type: `array`):

Keep only listings with one of these energy classes (e.g. \['A+','A','B']). Leave empty for all.

## `postedWithinDays` (type: `integer`):

Keep only listings first published in the last N days — ideal for daily/weekly monitoring of fresh inventory in an area.

## `withPhone` (type: `boolean`):

Return only listings that expose a contact phone number (lead generation). Automatically turns on Fetch full detail so the phone is captured on every record.

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

Open each listing's detail page to collect the full description, all photos, agent phone, GPS and amenities. This adds one extra request per listing (slower + more bandwidth) — leave off if the search-page fields are enough.

## `analyzeListings` (type: `boolean`):

Have an AI read each listing and add an 'ai' object: English summary + highlights (the Greek description translated/condensed), condition, view, furnished, and Airbnb potential. With an Investor profile below it also scores each listing (deal_score, estimated yield, buy/watch/skip). Paid Apify plan only — charged as a separate per-listing event ON TOP of listing-scraped. Tip: enable Fetch full detail too, so the AI has the full description to work from.

## `investorProfile` (type: `string`):

Free text describing your goal so the AI can score & rank listings, e.g. 'Golden-visa buyer, budget 300k, wants Airbnb income in central Athens' or 'Long-term rental, 8%+ gross yield, Thessaloniki'. Leave empty for translation/summary only.

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

Stop after this many listings (across all locations / start URLs combined). Each listing is charged at the per-event price — start small (e.g. 20) to validate the output before scaling up. Aliases accepted: 'limit', 'max', 'maxResultsPerSource'.

## `customProxyUrl` (type: `string`):

Leave empty — a residential proxy is already included, nothing to configure. Only fill this if you want to use YOUR OWN external residential/mobile proxy instead (http://user:pass@host:port). Spitogatos is behind Imperva, so a clean residential IP (ideally Greek/EU) is required. Sticky-session providers (a session-<token> in the credentials) are auto-rotated on a block. Example: http://user:pass_country-GR_session-abc_lifetime-1440@proxies.example.com:1000

## `proxyConfig` (type: `object`):

Leave as-is. A residential proxy is bundled with the actor, so it works out of the box — you do NOT need to bring your own. This Apify proxy setting is only used as a fallback if the included pool is temporarily unavailable, and is ignored when a Custom proxy URL is set.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.spitogatos.gr/en/for_sale-homes/athens-center"
    }
  ],
  "transaction": "buy",
  "propertyType": "homes",
  "locationQuery": [
    "Athens - Center"
  ],
  "areaIDs": [],
  "sortBy": "relevance",
  "priceDropsOnly": false,
  "newBuildOnly": false,
  "energyClass": [],
  "withPhone": false,
  "fetchDetails": false,
  "analyzeListings": false,
  "maxResults": 50,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Property listings scraped from Spitogatos.gr.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.spitogatos.gr/en/for_sale-homes/athens-center"
        }
    ],
    "locationQuery": [
        "Athens - Center"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dltik/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 = {
    "startUrls": [{ "url": "https://www.spitogatos.gr/en/for_sale-homes/athens-center" }],
    "locationQuery": ["Athens - Center"],
}

# Run the Actor and wait for it to finish
run = client.actor("dltik/spitogatos-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 '{
  "startUrls": [
    {
      "url": "https://www.spitogatos.gr/en/for_sale-homes/athens-center"
    }
  ],
  "locationQuery": [
    "Athens - Center"
  ]
}' |
apify call dltik/spitogatos-scraper --silent --output-dataset

```

## MCP server setup

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