# SeLoger France Property Scraper (`parsebird/seloger-france-scraper`) Actor

Scrape property listings from SeLoger.com, France's leading real estate portal. Extract prices, rooms, area, location, energy class, agency info, and photos for sale and rental listings.

- **URL**: https://apify.com/parsebird/seloger-france-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.09 / 1,000 property listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Extract property listings from [SeLoger.com](https://www.seloger.com/), France's leading real estate portal, without writing a single line of scraping code.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search any French city or paste a SeLoger search URL to get price, rooms, bedrooms, living area, floor, energy class, GPS location, agency contact info, and photos for sale and rental listings.
</td>
</tr></table>

<br>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Use the Apify actor "parsebird/seloger-france-scraper" (SeLoger France Property Scraper) via the ApifyClient SDK: `from apify_client import ApifyClient; client = ApifyClient("<APIFY_TOKEN>"); run = client.actor("parsebird/seloger-france-scraper").call(run_input={"mode": "search", "distributionType": "Buy", "estateTypes": ["Apartment"], "location": "AD08FR31096", "priceMax": 500000, "maxItems": 100})`. Key inputs: mode ("url" to scrape SeLoger search URLs directly, or "search" to build a query from filters), urls (array of SeLoger classified-search/classified-map URLs), distributionType ("Buy" or "Rent"), estateTypes (["Apartment", "House"]), location (SeLoger location code, e.g. AD08FR31096 for Paris), priceMin/priceMax (EUR), spaceMin (m²), roomsMin/bedroomsMin, maxItems (default 30, 0 = unlimited), maxPages (default 5), getDetails (boolean, fetches full description + GPS per listing). Output fields per listing: id, title, description, price, price_numeric, price_per_m2, currency, distribution_type, property_type, rooms, bedrooms, area_m2, floor, city, zipcode, district, latitude, longitude, energy_class, agent_name, agent_phone, images, floorplans, url. Full API spec: https://apify.com/parsebird/seloger-france-scraper/api. Get an API token at https://console.apify.com/settings/integrations.
```

### What does SeLoger France Property Scraper do?

**SeLoger France Property Scraper** is a SeLoger.com data extraction tool for buying, renting, and monitoring French real estate. Point it at a SeLoger search URL or describe a search with filters, and it returns clean, structured property data ready for analysis, lead generation, or market research — no browser, no manual copy-pasting.

- 🏠 Scrape both **Buy** and **Rent** listings for apartments and houses
- 🔗 **URL mode**: paste any `seloger.com/classified-search` or `classified-map` link and scrape it as-is
- 🔍 **Search mode**: build a query from location code, price range, living area, room count, and bedroom count
- 📍 Optional **full-detail mode** fetches each listing's detail page for the untruncated description and GPS coordinates
- 📸 Extracts up to 15 photos and floorplans per listing, plus agency name, phone, and address
- ⚡ No JavaScript rendering needed — listing data is parsed directly from the page, so runs are fast and cheap (a French residential proxy is used automatically to avoid IP-based blocking)
- 🔄 Schedule recurring runs on Apify to monitor new listings or price changes over time
- 🔌 Full [REST API](https://docs.apify.com/api/v2) access and integrations with Zapier, Make, Google Sheets, and webhooks
- 📤 Export results as **JSON, CSV, Excel, HTML, or XML** directly from the Apify Console

### What data can you extract from SeLoger.com?

| Field | Description |
|-------|-------------|
| `title`, `headline`, `description` | Listing title, agent headline, and description (full text with Fetch Full Details enabled) |
| `price`, `price_numeric`, `price_per_m2` | Formatted price, numeric price in EUR, and price per m² (sale listings) |
| `distribution_type`, `property_type` | BUY or RENT; APARTMENT or HOUSE |
| `rooms`, `bedrooms`, `area_m2`, `floor` | Room count, bedroom count, living area, and floor |
| `city`, `zipcode`, `district`, `country` | Location details |
| `latitude`, `longitude` | GPS coordinates (requires Fetch Full Details) |
| `transport` | Nearby metro and bus lines (e.g. `METRO:4`, `BUS:31`) |
| `energy_class` | DPE energy performance rating (A–G) |
| `agent_name`, `agent_phone`, `agent_address` | Listing agency or agent contact info |
| `is_exclusive`, `is_new`, `has_3d_visit` | Exclusive listing, new listing, and 3D virtual tour flags |
| `images`, `floorplans`, `image_count` | Photo URLs (up to 15), floorplan URLs, and total photo count |
| `url`, `created_at`, `updated_at` | Listing URL and creation/update timestamps |

### How to scrape SeLoger.com with this actor

1. Open **SeLoger France Property Scraper** on the Apify Console and go to the **Input** tab.
2. Pick an **Input Mode**: paste one or more SeLoger search URLs, or switch to "Search by filters" and enter a location code (see below), buy/rent, property type, and price/size filters.
3. Set **Max Listings** and **Max Pages** to control run size and cost.
4. Optionally enable **Fetch Full Details** to get the untruncated description and GPS coordinates for every listing (uses an extra charge per listing).
5. Click **Start** and download results as JSON, CSV, or Excel once the run finishes — or pull them via the [API](https://docs.apify.com/api/v2) or [Apify Client SDKs](https://docs.apify.com/api/client).

#### Finding a SeLoger location code

SeLoger identifies locations with a code such as `AD08FR31096` (Paris). To find the code for another city or district:

1. Go to [seloger.com](https://www.seloger.com/) and run a search for that location.
2. Copy the `locations=` value from the resulting URL's query string.

| Level | Prefix | Example | Description |
|-------|--------|---------|-------------|
| Country | `AD02` | `AD02FR1` | France |
| Region | `AD04` | `AD04FR5` | Île-de-France |
| Department | `AD06` | `AD06FR76` | Paris department |
| Commune | `AD08` | `AD08FR31096` | Paris (whole city) |
| Neighborhood | `NBH2` | `NBH2FR63` | A specific district |

### Output example

```json
{
  "id": "267L9HK3QHG1",
  "legacy_id": "279209957",
  "title": "Appartement à vendre",
  "headline": "Appartement 4 pièces",
  "price": "714 000 €",
  "price_numeric": 714000,
  "price_per_m2": "8 925 €/m²",
  "currency": "EUR",
  "distribution_type": "BUY",
  "property_type": "APARTMENT",
  "property_type_label": "Appartement",
  "rooms": 4,
  "bedrooms": 3,
  "area_m2": 80,
  "floor": "Étage 6/9",
  "city": "Paris 18ème arrondissement",
  "zipcode": "75018",
  "district": "Goutte d'Or-Château Rouge",
  "country": "FRA",
  "energy_class": "D",
  "agent_name": "Century 21 Sorim",
  "agent_phone": "0608656426",
  "images": ["https://mms.seloger.com/e/9/8/5/e9851a24-....jpg"],
  "url": "https://www.seloger.com/annonce/achat/ile-de-france/paris-75/paris-75000/267L9HK3QHG1",
  "source": "seloger.com"
}
```

Download the full dataset in **JSON, CSV, Excel, HTML, or XML** from the Apify Console, or fetch it programmatically:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("parsebird/seloger-france-scraper").call(run_input={
    "mode": "search",
    "distributionType": "Buy",
    "estateTypes": ["Apartment"],
    "location": "AD08FR31096",
    "priceMax": 500000,
    "maxItems": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["url"])
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('parsebird/seloger-france-scraper').call({
    mode: 'search',
    distributionType: 'Buy',
    estateTypes: ['Apartment'],
    location: 'AD08FR31096',
    priceMax: 500000,
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- **Real estate market research** — track average prices per m² by city or district over time
- **Lead generation** — build a list of listing agencies and their contact details for a target area
- **Price monitoring** — schedule daily runs to catch new listings or price drops as soon as they're published
- **Portfolio analysis** — feed structured listing data into a BI tool or spreadsheet for comparison
- **Investment sourcing** — filter by price, size, and room count to shortlist properties matching an investment criteria

### How it works

1. The actor requests the SeLoger.com search page for your URL or filters, exactly as a browser would.
2. SeLoger server-renders listing data into the page; the actor parses this structured data directly — no DOM scraping or browser rendering needed, which keeps runs fast and inexpensive.
3. Results are paginated automatically (about 30 listings per page) until **Max Listings** or **Max Pages** is reached.
4. With **Fetch Full Details** enabled, the actor additionally requests each listing's detail page to pull the untruncated description and GPS coordinates.
5. Every listing is pushed to the Apify dataset immediately, so partial results are available even if a run is stopped early.

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

This actor uses [Pay-Per-Event pricing](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) — you only pay for listings actually returned, not for compute time.

| Event | Price per event | Price per 1,000 |
|-------|-----------------|-----------------|
| `listing-scraped` | $0.00199 | **$1.99** |
| `detail-scraped` | $0.00069 | **$0.69** |

`listing-scraped` fires once per listing pushed to the dataset. `detail-scraped` fires once per listing only when **Fetch Full Details** is enabled. Scraping 1,000 listings without details costs about **$1.99**; with full details enabled, about **$2.68** per 1,000. New Apify accounts include free monthly platform usage credits that cover a meaningful number of runs — see [Apify pricing](https://apify.com/pricing) for current plan details.

### Is it legal to scrape SeLoger.com?

Scraping publicly available data, such as property listings visible without logging in, is generally permitted, but you should always comply with SeLoger's [terms of use](https://www.seloger.com/Conditions_Generales_d_Utilisation.html) and applicable data protection laws (including GDPR when handling any personal data such as agent contact details). Read more in Apify's [guide on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Other real estate scrapers by ParseBird

- [Fotocasa Scraper](https://apify.com/parsebird/fotocasa-scraper) — property listings from Fotocasa.es (Spain)
- [Immobiliare.it Scraper](https://apify.com/parsebird/immobiliare-it-scraper) — property listings from Immobiliare.it (Italy)
- [Daft.ie Property Scraper](https://apify.com/parsebird/daft-ie-property-scraper) — property listings from Daft.ie (Ireland)
- [Homegate.ch Swiss Real Estate Scraper](https://apify.com/parsebird/homegate-ch-scraper) — property listings from Homegate.ch (Switzerland)
- [Cian.ru Property Scraper](https://apify.com/parsebird/cian-ru-property-scraper) — property listings from Cian.ru (Russia)

### FAQ

**What's the difference between URL mode and Search mode?**
URL mode scrapes SeLoger search URLs exactly as you paste them — use it when you've already built a search on seloger.com and want to copy the link. Search mode builds the URL for you from location, price, and size filters, which is easier to automate with different parameters per run.

**Why are `latitude` and `longitude` empty by default?**
SeLoger only includes GPS coordinates on the listing detail page, not the search results page. Enable **Fetch Full Details** in the input to get coordinates (and the full description) for every listing.

**Does `roomsMin` / `bedroomsMin` actually filter the search on SeLoger.com?**
No — SeLoger's URL filters don't support minimum room or bedroom count, so the actor fetches results normally and filters them locally before pushing to the dataset. This means fewer items may reach your **Max Listings** limit than pages fetched would suggest; increase **Max Pages** if you need more matches.

**Can I scrape both Buy and Rent listings in one run?**
Not in a single search — SeLoger requires a single `distributionTypes` value per search. Run the actor twice (once per mode), or use URL mode with two separate URLs.

**Do I need a proxy?**
No action needed — the actor uses a French residential proxy automatically, since SeLoger.com blocks direct datacenter traffic. You can change the proxy group or country in the **Advanced** section if needed.

**Can I schedule this to run automatically?**
Yes. Use Apify's [Scheduler](https://docs.apify.com/platform/schedules) to run this actor daily, weekly, or at any interval to catch new listings or price changes.

**Something looks wrong or missing — how do I report it?**
Open an issue on the actor's Issues tab in Apify Console. SeLoger occasionally changes its page structure, and reports help keep the scraper up to date.

# Actor input Schema

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

Use existing SeLoger search URLs, or build a search from location and filters below.

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

SeLoger.com search URLs to scrape (classified-search or classified-map links). Only used when Input Mode is 'Search URLs'.

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

Search for listings to buy or to rent. Only used when Input Mode is 'Search by filters'.

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

Property types to include. Only used when Input Mode is 'Search by filters'.

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

SeLoger location code (e.g. AD08FR31096 for Paris). Copy it from the 'locations=' parameter of a SeLoger.com search URL — see the README for a lookup guide. Only used when Input Mode is 'Search by filters'.

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

Minimum price in euros. Leave at 0 for no minimum.

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

Maximum price in euros. Leave at 0 for no maximum.

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

Minimum living area in square meters. Leave at 0 for no minimum.

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

Minimum number of rooms (pièces). Applied by the scraper after fetching results, since SeLoger does not support this as a URL filter.

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

Minimum number of bedrooms (chambres). Applied by the scraper after fetching results, since SeLoger does not support this as a URL filter.

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

Maximum number of listings to scrape in total. Set to 0 for unlimited (up to Max Pages).

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

Maximum number of search result pages to fetch per URL (about 30 listings per page).

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

Open each listing's detail page to get the full untruncated description and GPS coordinates. Slower and uses an extra charge per listing.

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

SeLoger.com blocks direct datacenter traffic, so a French residential proxy is used by default. Change this only if you need a different proxy setup.

## Actor input object example

```json
{
  "mode": "url",
  "urls": [
    "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR31096"
  ],
  "distributionType": "Buy",
  "estateTypes": [
    "Apartment",
    "House"
  ],
  "location": "AD08FR31096",
  "priceMin": 0,
  "priceMax": 0,
  "spaceMin": 0,
  "roomsMin": 0,
  "bedroomsMin": 0,
  "maxItems": 30,
  "maxPages": 5,
  "getDetails": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "mode": "url",
    "urls": [
        "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR31096"
    ],
    "distributionType": "Buy",
    "estateTypes": [
        "Apartment",
        "House"
    ],
    "location": "AD08FR31096",
    "maxItems": 30,
    "maxPages": 5,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "mode": "url",
    "urls": ["https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR31096"],
    "distributionType": "Buy",
    "estateTypes": [
        "Apartment",
        "House",
    ],
    "location": "AD08FR31096",
    "maxItems": 30,
    "maxPages": 5,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/seloger-france-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 '{
  "mode": "url",
  "urls": [
    "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR31096"
  ],
  "distributionType": "Buy",
  "estateTypes": [
    "Apartment",
    "House"
  ],
  "location": "AD08FR31096",
  "maxItems": 30,
  "maxPages": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call parsebird/seloger-france-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/seloger-france-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/SW3Bz2NXuH60bw7M0/builds/rJZCt3ekONlSOCS31/openapi.json
