# Seloger France $1💰 Powerful Filters + Deep Search (`abotapi/seloger-france-scraper`) Actor

From $1/1K. Scrape property listings from seloger.com. Supports buy and rent searches with location, price, rooms, and property type filters. Extracts price, area, rooms, energy class, coordinates, images, agent info, transport lines, and descriptions.

- **URL**: https://apify.com/abotapi/seloger-france-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Developer tools, Automation
- **Stats:** 5 total users, 3 monthly users, 93.9% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## SeLoger France Property Scraper

Scrape property listings from seloger.com, France's leading real estate platform. Supports buy and rent searches with location, price, rooms, and property type filters. Extracts price, area, rooms, energy class, coordinates, images, agent info, transport lines, and descriptions.

### Features

- **Full France coverage** - search by commune, department, or region using SeLoger location codes
- **Buy & Rent** - supports both transaction types with all SeLoger filters
- **Rich structured data** - price, price/m2, rooms, bedrooms, area, energy class, transport, agent, floorplans
- **Coordinates** - latitude/longitude for every listing via geo API
- **~35 listings per page** with automatic pagination (up to 20 pages default)

### Quick Start

#### Buy apartments in Paris
```json
{
  "mode": "url",
  "urls": ["https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR31096"],
  "maxItems": 100
}
````

#### Search mode - houses in Toulouse under 500k

```json
{
  "mode": "search",
  "distributionType": "Buy",
  "estateTypes": ["House"],
  "location": "AD08FR31555",
  "priceMax": 500000,
  "maxItems": 200
}
```

#### Rent in Lyon with 3+ rooms

```json
{
  "mode": "search",
  "distributionType": "Rent",
  "estateTypes": ["Apartment", "House"],
  "location": "AD08FR69123",
  "roomsMin": 3
}
```

#### Large scrape with proxy

```json
{
  "mode": "url",
  "urls": ["https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=House,Apartment&locations=AD08FR31096"],
  "maxItems": 0,
  "maxPages": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

### Location Codes

SeLoger uses geographic ID codes for locations:

| Level | Prefix | Example | Description |
|-------|--------|---------|-------------|
| Country | `AD02` | `AD02FR1` | France |
| Region | `AD04` | `AD04FR5` | Ile-de-France |
| Department | `AD06` | `AD06FR76` | Paris department |
| Commune | `AD08` | `AD08FR31096` | Paris (city) |
| Neighborhood | `NBH2` | `NBH2FR63` | Patay-Massena |

To find a location code, search on seloger.com and copy the `locations=` parameter from the URL.

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `url` | `url` (use provided URLs) or `search` (build from filters) |
| `urls` | array | - | SeLoger search URLs (`/classified-search` or `/classified-map`) |
| `distributionType` | string | `Buy` | `Buy` or `Rent` (search mode) |
| `estateTypes` | array | `["House", "Apartment"]` | Property types (search mode) |
| `location` | string | - | SeLoger location code (search mode) |
| `priceMin` | integer | - | Minimum price in EUR |
| `priceMax` | integer | - | Maximum price in EUR |
| `roomsMin` | integer | - | Minimum number of rooms |
| `bedroomsMin` | integer | - | Minimum number of bedrooms |
| `spaceMin` | integer | - | Minimum area in m2 |
| `maxItems` | integer | `50` | Max listings to scrape (0=unlimited) |
| `maxPages` | integer | `20` | Max search result pages (~35 listings/page) |
| `getDetails` | boolean | `false` | Fetch full descriptions from detail pages (slower) |
| `proxy` | object | none | Proxy config. FR residential recommended for reliability |

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | SeLoger listing ID (e.g. "26HYJAJHL23Q") |
| `legacy_id` | string | Numeric legacy ID |
| `title` | string | Listing title (e.g. "Appartement a vendre") |
| `headline` | string | Agent headline |
| `description` | string | Listing description (truncated in search, full with `getDetails`) |
| `price` | string | Formatted price (e.g. "343 765 EUR") |
| `price_numeric` | integer | Price as number |
| `price_per_m2` | string | Price per square meter |
| `currency` | string | Always "EUR" |
| `distribution_type` | string | `BUY` or `RENT` |
| `property_type` | string | `APARTMENT`, `HOUSE` |
| `property_type_label` | string | French label (e.g. "Appartement") |
| `rooms` | integer | Number of rooms |
| `bedrooms` | integer | Number of bedrooms |
| `area_m2` | number | Living area in m2 |
| `floor` | string | Floor info |
| `city` | string | City name |
| `zipcode` | string | Postal code |
| `district` | string | District/neighborhood name |
| `country` | string | Always "FRA" |
| `latitude` | number | Property latitude |
| `longitude` | number | Property longitude |
| `transport` | array | Nearby transport lines (e.g. \["METRO:6", "BUS:25"]) |
| `energy_class` | string | Energy performance certificate (A-G) |
| `agent_name` | string | Real estate agent/agency name |
| `agent_phone` | string | Agent phone number |
| `agent_address` | string | Agency address |
| `is_exclusive` | boolean | Exclusive listing |
| `is_new` | boolean | New listing |
| `has_3d_visit` | boolean | 3D virtual tour available |
| `images` | array | Property image URLs (up to 15) |
| `floorplans` | array | Floorplan image URLs |
| `image_count` | integer | Total images available |
| `url` | string | Full listing URL |
| `portal` | string | Source portal (seloger, selogerneuf) |
| `created_at` | string | Listing creation date (ISO 8601) |
| `updated_at` | string | Last update date (ISO 8601) |
| `source` | string | Always "seloger.com" |

# Actor input Schema

## `mode` (type: `string`):

Scraping mode: 'search' builds URLs from locations and filters, 'url' uses provided seloger.com URLs directly

## `locations` (type: `array`):

City names, postcodes, neighborhoods, or SeLoger location codes (search mode). Examples: 'Paris', 'Toulouse', '75016', 'Paix Jartom, Tomblaine'. Names are auto-resolved. Each location is searched separately with maxPages per location.

## `urls` (type: `array`):

SeLoger search URLs for url mode. Supports /classified-search and /classified-map URLs.

## `distributionType` (type: `string`):

Type of transaction (search mode)

## `estateTypes` (type: `array`):

Types of properties to search (search mode)

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

Minimum price in euros

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

Maximum price in euros

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

Minimum number of rooms

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

Minimum number of bedrooms

## `spaceMin` (type: `integer`):

Minimum living space in square meters

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

Sort order for search results (search mode)

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

Maximum total listings across all locations (0=unlimited)

## `maxPages` (type: `integer`):

Maximum search result pages per location (~35 listings/page)

## `getDetails` (type: `boolean`):

Fetch full property details from detail pages. Slower but more complete data.

## `proxy` (type: `object`):

Proxy configuration. French residential proxy recommended for DataDome bypass.

## `dataset_name` (type: `string`):

Custom dataset name (leave empty for default)

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "Paris"
  ],
  "distributionType": "Buy",
  "estateTypes": [
    "House",
    "Apartment"
  ],
  "sortBy": "Default",
  "maxItems": 50,
  "maxPages": 20,
  "getDetails": false
}
```

# Actor output Schema

## `listings` (type: `string`):

Individual property listing records with full structured data.

## `metadata` (type: `string`):

Scraping run metadata including timing, counts, and configuration.

# 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 = {
    "locations": [
        "Paris"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/seloger-france-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 = { "locations": ["Paris"] }

# Run the Actor and wait for it to finish
run = client.actor("abotapi/seloger-france-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 '{
  "locations": [
    "Paris"
  ]
}' |
apify call abotapi/seloger-france-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seloger France $1💰 Powerful Filters + Deep Search",
        "description": "From $1/1K. Scrape property listings from seloger.com. Supports buy and rent searches with location, price, rooms, and property type filters. Extracts price, area, rooms, energy class, coordinates, images, agent info, transport lines, and descriptions.",
        "version": "0.1",
        "x-build-id": "cGqUnRNF85fXIFWYk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~seloger-france-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-seloger-france-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/abotapi~seloger-france-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-seloger-france-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/abotapi~seloger-france-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-seloger-france-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Scraping mode: 'search' builds URLs from locations and filters, 'url' uses provided seloger.com URLs directly",
                        "default": "search"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "City names, postcodes, neighborhoods, or SeLoger location codes (search mode). Examples: 'Paris', 'Toulouse', '75016', 'Paix Jartom, Tomblaine'. Names are auto-resolved. Each location is searched separately with maxPages per location.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Paris"
                        ]
                    },
                    "urls": {
                        "title": "Search URLs (url mode)",
                        "type": "array",
                        "description": "SeLoger search URLs for url mode. Supports /classified-search and /classified-map URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "distributionType": {
                        "title": "Transaction Type",
                        "enum": [
                            "Buy",
                            "Rent"
                        ],
                        "type": "string",
                        "description": "Type of transaction (search mode)",
                        "default": "Buy"
                    },
                    "estateTypes": {
                        "title": "Property Types",
                        "type": "array",
                        "description": "Types of properties to search (search mode)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "House",
                                "Apartment"
                            ]
                        },
                        "default": [
                            "House",
                            "Apartment"
                        ]
                    },
                    "priceMin": {
                        "title": "Min Price (EUR)",
                        "type": "integer",
                        "description": "Minimum price in euros"
                    },
                    "priceMax": {
                        "title": "Max Price (EUR)",
                        "type": "integer",
                        "description": "Maximum price in euros"
                    },
                    "roomsMin": {
                        "title": "Min Rooms",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of rooms"
                    },
                    "bedroomsMin": {
                        "title": "Min Bedrooms",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of bedrooms"
                    },
                    "spaceMin": {
                        "title": "Min Area (m2)",
                        "type": "integer",
                        "description": "Minimum living space in square meters"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "Default",
                            "DateDesc",
                            "PriceAsc",
                            "PriceDesc"
                        ],
                        "type": "string",
                        "description": "Sort order for search results (search mode)",
                        "default": "Default"
                    },
                    "maxItems": {
                        "title": "Max Items (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings across all locations (0=unlimited)",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max Pages (per location)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum search result pages per location (~35 listings/page)",
                        "default": 20
                    },
                    "getDetails": {
                        "title": "Get Full Details",
                        "type": "boolean",
                        "description": "Fetch full property details from detail pages. Slower but more complete data.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration. French residential proxy recommended for DataDome bypass."
                    },
                    "dataset_name": {
                        "title": "Dataset Name",
                        "type": "string",
                        "description": "Custom dataset name (leave empty for default)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
