# SeLoger Scraper API - Annonces, Prix au m², DPE & Agences (`scrapifier/seloger-scraper`) Actor

⚡ Extract unlimited SeLoger listings in seconds! Drop your search URL and get rich, structured real estate data — price, surface, rooms, location, DPE & more. Perfect for market analysis, investment scouting, price benchmarking or lead generation. Automate the French property market & stay ahead! 🏡

- **URL**: https://apify.com/scrapifier/seloger-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 9 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.96 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## SeLoger Scraper API - Annonces, Prix au m², DPE & Agences

Scrape real-estate listings from SeLoger by location and filters or from a SeLoger search URL, and export them as JSON, CSV or Excel, or pull them straight from the API.

⚡ For every listing you get the **price**, **surface**, **rooms** and bedrooms, the **DPE energy rating**, title, headline and full description, floor, key facts, city, postal code and district, creation and update dates, photos, nearby transport and the **agency name and phone numbers**. Search with **friendly filters** (rent or buy, cities or postal codes, price, surface, rooms, bedrooms) or paste any SeLoger search URL. **No account and no cookies** to provide, the Actor **goes past SeLoger's 2,500-result cap** by splitting large searches by price, and you **pay per listing**.

[![Apify Actor](https://apify.com/actor-badge?actor=scrapifier/seloger-scraper)](https://apify.com/scrapifier/seloger-scraper)

### 🎯 Why scrape SeLoger listings?

- **Price monitoring**: track asking prices and rents per m² in a city or arrondissement week after week, and spot price drops.
- **Investment scouting**: pull every apartment for sale under your budget in several cities, then rank them by price per m², DPE and floor in a spreadsheet.
- **Lead generation**: collect the agencies and private sellers active in your area, with their phone numbers, for prospecting or partnerships.
- **Market research**: measure supply by property type, surface and energy rating across regions, and how long listings stay online.
- **Rental search**: watch new rentals matching your budget, surface and rooms, delivered to a sheet or a Slack channel.
- **Academic and data journalism**: build datasets of French housing listings for studies on housing costs or energy performance.

### 📊 What data does SeLoger Scraper extract?

| Field | Description |
|---|---|
| `id`, `legacy_id` | Listing id (alphanumeric on the detail page, numeric on the search summary) and the numeric legacy id |
| `url` | Direct link to the listing on seloger.com |
| `title`, `headline`, `description` | Title, short teaser and full description text |
| `distribution_type` | Rent or sale |
| `property_type` | Apartment, house... |
| `creation_date`, `update_date` | Publication date and last update date |
| `rooms`, `bedrooms` | Number of rooms and bedrooms |
| `surface` | Living surface in m² (may be decimal) |
| `floor` | Floor, or floor / total floors (for example `4/6`) |
| `keyfacts[]` | Key facts list (heating, exposure...) |
| `price` | Asking price or monthly rent, as a number — always present, with or without full details |
| `price_display`, `square_meter_price` | Price and price per m² as shown on the site (`710 000 €`, `14 702,84 €/m²`) |
| `price_type` | `SALE` or `RENT` |
| `prices{}` | Full price breakdown from the listing page (label to amount): asking price, estimated notary fees and total project cost for a sale; rent, charges and deposit for a rental |
| `epc` | Energy performance (DPE) letter, A to G |
| `energy[]` | Energy details (heating, condition, estimated bill) |
| `city`, `zip_code`, `district` | City or arrondissement, postal code and district |
| `lat`, `lng` | Latitude and longitude |
| `transport[]` | Nearby transport lines by type |
| `features[]` | Amenities (icon and value) |
| `photos[]`, `floorplans[]`, `virtual_tours[]` | Photo, floorplan and virtual tour URLs |
| `contact_name`, `contact_phones[]` | Agency or seller name and contact phone numbers |
| `is_private_seller` | `true` when the seller is a private individual |
| `is_exclusive`, `has_3d_visit`, `has_brokerage_fee`, `is_new` | Exclusive listing, 3D visit available, brokerage fee applies, flagged as new |
| `scraped_at` | Extraction timestamp (UTC) |
| `detail_error` | Set only when the detail page could not be fetched and the search summary was used instead |

The search results already carry the description, photos, price, surface, rooms, DPE, transport and the agency phone. Turn on `fetch_details` only when you also need every photo, the full feature list, exact GPS and the price breakdown: it opens each listing's own page. Nothing is lost by turning it on — the detail is merged on top of the search result, so `price` and the other search fields stay in place.

### 🚀 How to scrape SeLoger listings

1. Open the Actor, pick **Rent** or **Buy** in `transaction`, and type one or more **locations** (cities, arrondissements or postal codes such as `Paris 11`, `Lyon`, `75011`). Each is resolved automatically.
2. Narrow the search with **Property types**, **Min / Max price**, **Min / Max surface**, **Min rooms** and **Min bedrooms**. Or skip the filters and paste a SeLoger search URL from your address bar into `urls_list`.
3. Set **Max pages** per search (`10` by default, `0` = all reachable pages). Leave **Get more than 2500 results** on so large searches are split by price and collected in full.
4. Leave **Fetch full listing details** off for a cheap, fast run, and keep the prefilled **Residential FR proxy**.
5. Click **Start**. Listings are pushed to the dataset in batches of 50 while the run progresses.
6. Open the **Storage** tab to preview the listings and export them as JSON, CSV, Excel or XML, or read them from the dataset API.

The same run can be started from the Apify API, the Python or JavaScript client, or put on a schedule for daily monitoring.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Transaction | `transaction` | select | `rent` | `rent` (location) or `buy` (achat). |
| Locations (city / postal code) | `locations` | array of strings | `["Paris 11"]` | Cities, arrondissements or postal codes (`Paris 11`, `Lyon`, `75011`, `Bordeaux`), each resolved automatically. |
| Property types | `property_types` | multi-select | `["apartment"]` | `apartment` and/or `house`. Leave empty for both. |
| Min price (€) | `price_min` | integer | none | Minimum price (monthly rent or sale price, in €). |
| Max price (€) | `price_max` | integer | none | Maximum price (monthly rent or sale price, in €). |
| Min surface (m²) | `surface_min` | integer | none | Minimum living surface in m². |
| Max surface (m²) | `surface_max` | integer | none | Maximum living surface in m². |
| Min rooms | `rooms_min` | integer | none | Minimum number of rooms, 1 to 5 (`5` = 5 and more). |
| Min bedrooms | `bedrooms_min` | integer | none | Minimum number of bedrooms, 1 to 5 (`5` = 5 and more). |
| Search URLs | `urls_list` | array of strings | none | Advanced: SeLoger `classified-search?...` URLs copied from the address bar (older `list.htm?...` URLs also work). When set, URLs take precedence over the filters. |
| Max pages | `max_pages` | integer | `10` | Pages to scrape per search. `0` = all reachable pages. Big runs are slower, so raise the run timeout accordingly. |
| Get more than 2500 results (split by price) | `split_intervals` | boolean | `true` | A single SeLoger search returns at most about 2,500 results; when there are more, the search is split into price intervals and collected in full. |
| Fetch full listing details (costs more) | `fetch_details` | boolean | `false` | Open each listing's own page for every photo, the full feature list and exact GPS. Much slower and more expensive. |
| Concurrency | `concurrency` | integer | `8` | Listings fetched in parallel (1 to 32). Higher is faster; keep it moderate and pair it with a good residential proxy. |
| Delay between requests (seconds) | `delay_between_pages` | number | `0` | Wait time between requests (politeness), 0 to 10. `0` = fastest. |
| Proxy configuration | `proxyConfiguration` | object | Apify Residential, country FR | Residential proxies in France are strongly recommended for reliable runs. |

Example input:

```json
{
  "transaction": "rent",
  "locations": ["Paris 11", "Lyon"],
  "property_types": ["apartment"],
  "price_max": 1500,
  "surface_min": 30,
  "rooms_min": 2,
  "max_pages": 10
}
```

Locations are geocoded one by one and the first match is kept, so prefer a postal code (`75011`) over an ambiguous town name. If you fill both `urls_list` and the filters, only the URLs are used: clear `urls_list` to search with the filters instead.

### 📤 Output example

Each listing is one dataset item, exportable as JSON, CSV, Excel or via the API.

```json
{
  "id": 268219497,
  "url": "https://www.seloger.com/annonces/achat/appartement/paris-3eme-75/archives/268219497.htm",
  "title": "Appartement à vendre",
  "distribution_type": "BUY",
  "property_type": "APARTMENT",
  "price": 710000,
  "price_display": "710 000 €",
  "square_meter_price": "14 702,84 €/m²",
  "price_type": "SALE",
  "prices": {
    "Prix du bien": "710 000 €",
    "Frais de notaires estimés": "56 800 €",
    "Montant estimé du projet": "766 800 €"
  },
  "surface": 48.29,
  "rooms": 2,
  "bedrooms": 1,
  "epc": "E",
  "city": "Paris 3ème arrondissement",
  "zip_code": "75003",
  "creation_date": "2026-10-02"
}
```

Turning `fetch_details` on only ever **adds** fields: every row keeps the price, photos and agency details from the search results, and gains the full description, the complete photo set, exact GPS, transport and the price breakdown.

The run's OUTPUT record holds the run statistics: searches, listings extracted, errors, detail fallbacks and deleted listings.

### 💡 Ready-to-run examples

**Apartments for rent in Paris 11 and Lyon, under 1,500 € with 30 m² and 2 rooms minimum**

```json
{ "transaction": "rent", "locations": ["Paris 11", "Lyon"], "property_types": ["apartment"], "price_max": 1500, "surface_min": 30, "rooms_min": 2, "max_pages": 10 }
```

**Every house for sale in Bordeaux, full result set**

```json
{ "transaction": "buy", "locations": ["Bordeaux"], "property_types": ["house"], "max_pages": 0, "split_intervals": true }
```

**From a SeLoger search URL copied from the browser**

```json
{ "urls_list": ["https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=House,Apartment&locations=AD08FR31096"], "max_pages": 10 }
```

**Full listing details (all photos, features, GPS) for one postal code**

```json
{ "transaction": "rent", "locations": ["75011"], "property_types": ["apartment"], "max_pages": 10, "fetch_details": true, "concurrency": 8 }
```

### 💰 Pricing: how much does it cost to scrape SeLoger?

**$0.96 per 1,000 listings**, flat. You pay only for the results you receive, there is no subscription and no start fee. New Apify accounts get free monthly platform credits to try it.

Cost is driven by the number of listings returned: cap each search with `max_pages` and narrow the filters (`price_max`, `surface_min`, `rooms_min`) before you pay for the results. `fetch_details` opens one extra page per listing, which adds proxy and compute usage.

### ⚙️ Performance, proxies and limits

- **Residential FR proxy recommended.** A residential FR proxy gives the most reliable runs. Without one, some requests may be blocked and counted as errors in the OUTPUT record.
- **2,500-result cap**: a single SeLoger search exposes at most about 2,500 results. With `split_intervals` on, the search is split into price intervals that each fit under the cap, scraped in parallel. Set `max_pages` to `0` to collect everything.
- **Concurrency**: `concurrency` (default `8`, up to `32`) bounds parallel requests. `delay_between_pages` adds a pause between requests; at `0` the client still keeps a 0.5 s minimum delay.
- **Summary vs detail mode**: by default one request per page of results is enough. `fetch_details` makes one extra request per listing and slows the run down considerably.
- **Detail fallbacks**: when a detail page cannot be fetched (listing deleted, partner site such as bellesdemeures, transient block), the search summary is kept and tagged in `detail_error`. One failed listing never aborts the search.
- **Deduplication**: listings are deduplicated by id within each search, including across price intervals.
- **Timeout**: big runs are slower, so raise the run timeout for large jobs.
- **Nothing to scrape**: with no `urls_list` and no resolvable `locations`, the run stops with an explicit error in the log and zero listings.

### 🔌 Integrations and API

Run SeLoger Scraper from the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or on a [schedule](https://docs.apify.com/platform/schedules). Connect it to Make, Zapier, n8n, Google Sheets, Slack or any webhook through [Apify integrations](https://apify.com/integrations). Every run's dataset is available as JSON, CSV, Excel or XML from the dataset API.

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapifier~seloger-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "transaction": "rent", "locations": ["Paris 11", "Lyon"], "property_types": ["apartment"], "price_max": 1500, "surface_min": 30, "rooms_min": 2, "max_pages": 10 }'
```

### ❓ FAQ

**Is it legal to scrape SeLoger?**

The Actor only reads listings that SeLoger publishes to anyone without logging in. Listings contain personal data (seller names, phone numbers), so process them in line with GDPR, respect SeLoger's terms of use, and stay responsible for your use of the data. This is not legal advice.

**Do I need a SeLoger account, login or cookies?**

No. Nothing to log in to and no cookie to paste. A residential FR proxy is recommended for the most reliable runs.

**Which SeLoger URLs are supported?**

Search URLs only: the `classified-search?...` URL shown in your address bar after a search on seloger.com, and the older `list.htm?...` format. Transaction, property types, locations, price, surface and minimum rooms are read from the URL.

**Can I export SeLoger listings to Excel or Google Sheets?**

Yes. Every run's dataset downloads as CSV, XLSX, JSON or XML from the Storage tab, and the Google Sheets integration can push new listings to a sheet automatically.

**How many listings can I scrape?**

A single SeLoger search is capped at about 2,500 results, but `split_intervals` (on by default) splits large searches by price and collects the full set. Set `max_pages` to `0` for everything, or keep a page cap to control cost and runtime.

**Does it cover both rentals and sales, apartments and houses?**

Yes. `transaction` switches between `rent` and `buy`, `property_types` takes `apartment`, `house` or both, and several cities or postal codes fit in one run.

**Why are some fields empty or why is `detail_error` set?**

Search summaries do not carry every field (exact GPS, floorplans and full features come with `fetch_details`). `detail_error` appears when a listing's own page could not be fetched (deleted, partner site, or momentarily blocked) and the summary was kept instead.

**How fresh is the data?**

Every run scrapes SeLoger live. Schedule the Actor daily to catch new listings and price changes.

### 🔗 Related scrapers

- [Leboncoin Real Estate Scraper](https://apify.com/scrapifier/leboncoin-immobilier-scraper): Leboncoin real-estate listings by filters, no URL needed.
- [PAP Scraper](https://apify.com/scrapifier/pap-immobilier-scraper): private-seller real estate from pap.fr.
- [Bien'ici Scraper](https://apify.com/scrapifier/bienici-scraper): real-estate listings from Bien'ici.
- [Leboncoin Scraper](https://apify.com/scrapifier/leboncoin-scraper): any Leboncoin search URL, all categories.

### 🇫🇷 En français

SeLoger Scraper est un scraper SeLoger qui permet d'extraire les annonces immobilières de seloger.com sans écrire de code. Choisissez location ou achat, saisissez une ou plusieurs villes, arrondissements ou codes postaux, puis filtrez par prix, surface, nombre de pièces et de chambres, ou collez simplement l'URL d'une recherche SeLoger. Pour chaque annonce vous obtenez le prix, la surface, les pièces, le DPE, la description, les photos, l'adresse, les transports à proximité, le nom de l'agence et ses numéros de téléphone. Les recherches de plus de 2 500 résultats sont découpées automatiquement par tranche de prix pour récupérer l'ensemble des annonces. Les données s'exportent en CSV, Excel ou JSON, ou se récupèrent via l'API Apify pour alimenter Google Sheets, Make ou n8n. Le tarif est au résultat : 0,96 $ pour 1 000 annonces, sans abonnement. Un proxy résidentiel français est recommandé pour des runs fiables.

### 💬 Support

Questions, bugs or a feature request? Open an issue in the **Issues** tab of this Actor, I answer quickly. If SeLoger Scraper saves you time, a rating on the Store helps others find it.

# Actor input Schema

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

Rent or buy.

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

One or more cities, arrondissements or postal codes, e.g. "Paris 11", "Lyon", "75011", "Bordeaux". Each is resolved automatically.

## `property_types` (type: `array`):

Apartment and/or house. Leave empty for both.

## `price_min` (type: `integer`):

Minimum price (monthly rent or sale price, in €).

## `price_max` (type: `integer`):

Maximum price (monthly rent or sale price, in €).

## `surface_min` (type: `integer`):

Minimum living surface in m².

## `surface_max` (type: `integer`):

Maximum living surface in m².

## `rooms_min` (type: `integer`):

Minimum number of rooms (5 = 5 and more).

## `bedrooms_min` (type: `integer`):

Minimum number of bedrooms (5 = 5 and more).

## `urls_list` (type: `array`):

Advanced: instead of the filters above, do a search on SeLoger.com and paste the URL from your browser's address bar (e.g. https://www.seloger.com/classified-search?distributionTypes=Buy\&estateTypes=House,Apartment\&locations=AD08FR31096). The older list.htm?... URLs also work. If set, URLs take precedence over the filters above.

## `max_pages` (type: `integer`):

Maximum number of pages to scrape per search. Set 0 to scrape all reachable pages. A single SeLoger search returns at most ~2500 results — narrow your filters to go beyond. Big runs are slower, so raise the run timeout accordingly.

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

Hard stop on the number of listings this run returns, across every search. Leave at 0 for no limit. You are billed per listing, so set it on first runs to keep a run predictable.

## `split_intervals` (type: `boolean`):

ON by default. A single SeLoger search returns at most ~2500 results — when there are more, the Actor automatically collects the full set for you. Set 'Max pages' to 0 to get everything.

## `fetch_details` (type: `boolean`):

OFF by default to keep runs cheap and fast. The search results already include description, photos, price, surface, rooms, DPE, transport and the agency phone. Turn this ON only if you also need every photo, the full feature list and exact GPS — it opens each listing's own page, which makes the run much slower and more expensive.

## `concurrency` (type: `integer`):

How many listings to fetch in parallel. Higher = faster; keep it moderate and pair it with a good residential proxy.

## `delay_between_pages` (type: `number`):

Wait time between requests (politeness). 0 = fastest.

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

Residential proxies in France are strongly recommended for reliable runs.

## Actor input object example

```json
{
  "transaction": "rent",
  "locations": [
    "Paris 11"
  ],
  "property_types": [
    "apartment"
  ],
  "max_pages": 10,
  "maxItems": 100,
  "split_intervals": true,
  "fetch_details": false,
  "concurrency": 8,
  "delay_between_pages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

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

All SeLoger listings extracted by this run.

# 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 = {
    "transaction": "rent",
    "locations": [
        "Paris 11"
    ],
    "property_types": [
        "apartment"
    ],
    "max_pages": 10,
    "maxItems": 100,
    "split_intervals": true,
    "fetch_details": false,
    "concurrency": 8,
    "delay_between_pages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/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 = {
    "transaction": "rent",
    "locations": ["Paris 11"],
    "property_types": ["apartment"],
    "max_pages": 10,
    "maxItems": 100,
    "split_intervals": True,
    "fetch_details": False,
    "concurrency": 8,
    "delay_between_pages": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/seloger-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 '{
  "transaction": "rent",
  "locations": [
    "Paris 11"
  ],
  "property_types": [
    "apartment"
  ],
  "max_pages": 10,
  "maxItems": 100,
  "split_intervals": true,
  "fetch_details": false,
  "concurrency": 8,
  "delay_between_pages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call scrapifier/seloger-scraper --silent --output-dataset

```

## MCP server setup

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