# SeLoger Scraper — French Real Estate Listings & Prices (`studio-amba/seloger-scraper`) Actor

Scrape real estate listings from seloger.com — France's #1 property portal. Extract prices, photos, property details, energy labels, and agency info for apartments, houses, and more.

- **URL**: https://apify.com/studio-amba/seloger-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

### What does SeLoger Scraper do?

**SeLoger Scraper** extracts real estate listings from [SeLoger.com](https://www.seloger.com) — France's largest and most popular property portal. It collects **prices, property details, photos, energy labels, agency info**, and more for apartments, houses, land, and commercial properties across all French cities. No login or cookies required.

Use the Apify platform to run this scraper on a schedule, access results via API, or integrate with tools like Google Sheets, Slack, Zapier, and Make.

### Why use SeLoger Scraper?

- **Market research** — Track property prices across French cities, compare neighborhoods, and identify market trends
- **Lead generation** — Collect real estate agency listings for B2B outreach or partnership opportunities
- **Price monitoring** — Set up scheduled runs to track price changes for specific cities or property types
- **Data analysis** — Export structured data to CSV, JSON, or Excel for portfolio analysis and investment decisions
- **Competitive intelligence** — Monitor competitor listings, pricing strategies, and market positioning

### How to scrape SeLoger listings

1. Go to the [SeLoger Scraper](https://apify.com/jelledesramaults/seloger-scraper) page on Apify
2. Click **Try for free** to open the actor in Apify Console
3. Enter a city name (e.g., "paris", "lyon", "marseille")
4. Select listing type: **For Sale** or **For Rent**
5. Optionally filter by property type (apartment, house, etc.)
6. Set the maximum number of results you need
7. Click **Start** and wait for the scraper to finish
8. Download your data in JSON, CSV, Excel, or HTML format

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `city` | String | No | City name to search (default: "paris"). Examples: "lyon", "marseille", "bordeaux" |
| `listingType` | String | No | "buy" (default) or "rent" |
| `propertyType` | String | No | Filter: "appartement", "maison", "terrain", "parking", "local-commercial", or empty for all |
| `maxResults` | Integer | No | Maximum listings to return (default: 100) |
| `proxyConfiguration` | Object | No | Proxy settings. Residential proxies strongly recommended |

### Output

Each listing contains:

| Field | Type | Example |
|-------|------|---------|
| `title` | String | `"Appartement 3 pièces 65 m²"` |
| `price` | Number | `450000` |
| `currency` | String | `"EUR"` |
| `listingType` | String | `"buy"` |
| `propertyType` | String | `"apartment"` |
| `address` | String | `"Rue de Rivoli"` |
| `city` | String | `"Paris"` |
| `postalCode` | String | `"75001"` |
| `surface` | Number | `65` |
| `rooms` | Number | `3` |
| `bedrooms` | Number | `2` |
| `floor` | String | `"3"` |
| `energyLabel` | String | `"D"` |
| `agencyName` | String | `"Century 21 Paris Centre"` |
| `imageUrl` | String | Main listing photo URL |
| `imageUrls` | Array | All listing photo URLs |
| `url` | String | Full listing URL on SeLoger |
| `scrapedAt` | String | `"2026-04-06T10:30:00.000Z"` |

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Example output

```json
{
    "title": "Appartement 3 pièces 65 m²",
    "price": 450000,
    "currency": "EUR",
    "listingType": "buy",
    "propertyType": "apartment",
    "address": "Rue de Rivoli",
    "city": "Paris 1er",
    "postalCode": "75001",
    "surface": 65,
    "rooms": 3,
    "bedrooms": 2,
    "floor": "3",
    "energyLabel": "D",
    "agencyName": "Century 21 Paris Centre",
    "imageUrl": "https://v.seloger.com/...",
    "imageUrls": ["https://v.seloger.com/...", "https://v.seloger.com/..."],
    "url": "https://www.seloger.com/annonces/achat/appartement/paris-1er/123456.htm",
    "scrapedAt": "2026-04-06T10:30:00.000Z"
}
````

### How much does it cost to scrape SeLoger?

SeLoger requires browser-based scraping with residential proxies due to its anti-bot protection. Estimated costs:

- **~50 listings** per run: ~0.5 compute units (~$2.50)
- **~500 listings** across multiple pages: ~3 compute units (~$15)

Costs vary based on proxy usage and the number of pages scraped. Use the `maxResults` parameter to control run costs.

### Tips for best results

- **Use residential proxies** — SeLoger has strong anti-bot protection. Residential proxies are required for reliable scraping
- **Start small** — Test with `maxResults: 10` before running large jobs
- **Schedule runs** — Set up daily or weekly schedules to track market changes
- **Filter by property type** — Narrow results to reduce costs and get more relevant data

### FAQ and support

**Is it legal to scrape SeLoger?**
This actor extracts publicly available data from SeLoger.com. Users are responsible for ensuring their use complies with applicable laws and the website's terms of service.

**Why are some fields empty?**
Not all listings include every detail (e.g., floor number, energy label). The scraper returns `null` for missing fields.

**The scraper returned 0 results?**
SeLoger uses heavy anti-bot protection. Make sure you're using residential proxies in the proxy configuration.

**Need a custom solution?**
If you need modifications or a custom scraper, open an issue on the [Issues tab](https://apify.com/jelledesramaults/seloger-scraper/issues) or contact the developer.

# Actor input Schema

## `city` (type: `string`):

City name to search (e.g. 'paris', 'lyon', 'marseille', 'bordeaux', 'toulouse'). Case-insensitive.

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

Type of listing to scrape.

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

Filter by property type. Leave empty for all types.

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

Maximum number of listings to return.

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

Proxy settings. REQUIRED — SeLoger uses heavy anti-bot protection. Use Apify residential proxies for best results.

## Actor input object example

```json
{
  "city": "paris",
  "listingType": "buy",
  "propertyType": "",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "city": "paris",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/seloger-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 = {
    "city": "paris",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Scraper — French Real Estate Listings & Prices",
        "description": "Scrape real estate listings from seloger.com — France's #1 property portal. Extract prices, photos, property details, energy labels, and agency info for apartments, houses, and more.",
        "version": "0.1",
        "x-build-id": "we9gRASVcR1cVRfkN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~seloger-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-seloger-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/studio-amba~seloger-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-seloger-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/studio-amba~seloger-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-seloger-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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to search (e.g. 'paris', 'lyon', 'marseille', 'bordeaux', 'toulouse'). Case-insensitive.",
                        "default": "paris"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "buy",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Type of listing to scrape.",
                        "default": "buy"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "appartement",
                            "maison",
                            "terrain",
                            "parking",
                            "local-commercial"
                        ],
                        "type": "string",
                        "description": "Filter by property type. Leave empty for all types.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. REQUIRED — SeLoger uses heavy anti-bot protection. Use Apify residential proxies for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
