# SeLoger.com French Real Estate Scraper (`parseforge/seloger-scraper`) Actor

Scrape French real estate listings from SeLoger.com — apartments, houses, studios and more. Extract price, surface area, rooms, bedrooms, DPE/GES energy ratings, agency info, images and 20+ structured fields. Perfect for investors analyzing the French property market.

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

## Pricing

from $9.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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🏠 SeLoger.com French Real Estate Scraper

Whether you're a real estate investor analyzing the French property market, a relocation agency helping clients find their dream home in France, or a data analyst tracking property trends across cities — this actor makes it easy to collect French real estate listings without writing a single line of code.

> **The SeLoger.com French Real Estate Scraper collects property listings with up to 24 data fields per listing, including energy performance diagnostics, price per square meter calculations, and full image galleries.**

### ✨ What Does It Do

- 💰 **Price & Price per m²** — Track property prices and automatically calculated price per square meter for value comparisons
- 🏢 **Property Type** — Identify apartments, houses, studios, and other property categories
- 📐 **Surface Area** — Collect exact living area in square meters for size-based filtering
- 🛏️ **Rooms & Bedrooms** — Count total rooms and bedrooms to match buyer requirements
- ⚡ **DPE & GES Energy Ratings** — Get official French energy performance classes (A–G) for consumption and greenhouse gas emissions
- 🔥 **Heating Type** — See what kind of heating each property uses
- 🏗️ **Agency & Features** — Get listing agency name, property features, floor level, and more
- 🖼️ **Image Gallery** — Collect all property photos from each listing
- 📍 **Location Details** — Get city, postal code, neighborhood, and floor information

### 🎬 Demo Video

_Coming soon_

### 🔧 Input

**Start URL** — Direct SeLoger.com search URL to scrape. If provided, the city and transaction type inputs are ignored and the URL is used directly. Use this to target specific neighborhoods or searches.

**Transaction Type** — Choose between buying (Achat) or renting (Location) properties.

**City** — French city slug with department code. Examples: paris-75, lyon-69, marseille-13, bordeaux-33, nice-06, toulouse-31.

**Max Items** — How many property listings to collect per run. Free users are limited to 10 items.

**Proxy Configuration** — Recommended for large-scale collection. SeLoger.com may limit repeated requests from the same IP address.

Example input:
```json
{
  "startUrl": "https://www.seloger.com/immobilier/achat/immo-paris-75/",
  "transactionType": "achat",
  "city": "paris-75",
  "maxItems": 10
}
````

### 📊 Output

Each property listing includes up to 24 structured data fields:

| 💰 Price | 💰 Price per m² | 🏢 Property Type |
|---|---|---|
| 🛏️ Rooms | 🛏️ Bedrooms | 📐 Surface (m²) |
| 🏢 Floor | 📍 Neighborhood | 📍 City |
| 📮 Postal Code | 📝 Description | ⚡ DPE Class |
| ⚡ GES Class | 🔥 Heating Type | 📋 Features |
| 💼 Agency Name | 🖼️ Images | 🔗 Listing URL |
| 🆔 Listing ID | 🏗️ New Build | 📋 Transaction Type |
| ⏰ Scraped At | ⚠️ Error (if any) | |

Example output:

```json
{
  "listingUrl": "https://www.seloger.com/annonces/123456789.htm",
  "listingId": "123456789",
  "imageUrl": "https://mms.seloger.com/img/photo.jpg",
  "propertyType": "Appartement",
  "price": 485000,
  "pricePerM2": 9699,
  "rooms": 3,
  "bedrooms": 2,
  "surfaceM2": 50,
  "floor": "2ème étage",
  "neighborhood": "Montmartre",
  "city": "Paris",
  "postalCode": "75018",
  "dpeClass": "C",
  "gesClass": "D",
  "agencyName": "Agence Parisienne",
  "isNewBuild": false,
  "transactionType": "Buy",
  "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

### 💎 Why Choose the SeLoger.com French Real Estate Scraper?

| Feature | Our Actor | Typical Alternatives |
|---|---|---|
| DPE and GES energy rating extraction | ✔️ | ✘ |
| Automatic price per m² calculation | ✔️ | ✘ |
| Full property image gallery collection | ✔️ | ✔️ |
| Agency name and contact details | ✔️ | ✘ |
| New build badge detection | ✔️ | ✘ |
| CSV, Excel, and JSON export | ✔️ | ✔️ |
| Automatic retry with rate limit handling | ✔️ | ✔️ |
| Support for large-scale collection (1M+ items) | ✔️ | ✔️ |
| Buy and rent transaction support | ✔️ | ✔️ |

### 📋 How to Use

No technical skills required. Follow these three simple steps:

1. **Sign Up** — [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** — Enter your search city (e.g. paris-75) and set max items
3. **Run It** — Click "Start" and watch your results appear

That's it. No coding, no setup needed. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Real Estate Investor** — Monitor property prices across French cities to identify undervalued neighborhoods and track price trends over time
- 💼 **Relocation Agency** — Collect available properties matching client criteria daily to provide up-to-date options for international relocations to France
- 🔬 **Market Researcher** — Track property listings week-over-week to analyze supply, pricing, and energy efficiency trends in the French real estate market

### ❓ FAQ

**🔍 How does this scraper work?**
The scraper fetches SeLoger.com search result pages and extracts individual listing details. It visits each listing page and collects structured property data including price, surface area, energy ratings, images, and more.

**📊 What cities are supported?**
Any city listed on SeLoger.com is supported. Use the city slug format with department code, for example: paris-75, lyon-69, marseille-13, bordeaux-33, nice-06, toulouse-31.

**📅 Can I schedule this to run automatically?**
Yes. Use the Apify scheduler to run this actor on a daily, weekly, or monthly basis. You can also integrate it with Make, Zapier, or GitHub Actions for automated property feed updates.

**⚖️ Is collecting data from SeLoger.com allowed?**
You are collecting publicly visible data from a public website. Always review the site terms of service and ensure your use case complies with local laws and regulations.

**🛡️ Will I get blocked?**
The actor includes built-in rate limiting between requests and smart retry logic to avoid triggering protections. For large-scale scraping, using the proxy configuration is recommended.

**⚡ How long does a run take?**
A run collecting 10 listings takes approximately 20–30 seconds due to delays between requests. Each listing requires a separate page visit.

**⚠️ Are there any limits?**
Free users get up to 10 items per run. Paid users can collect up to 1,000,000 results per run.

### 🔗 Integrate SeLoger.com French Real Estate Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) — Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) — Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) — Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) — Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) — Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) — Export to spreadsheets

### 💡 More ParseForge Actors

- [James Edition Real Estate Scraper](https://apify.com/parseforge/james-edition-real-estate-scraper) — Extract luxury real estate listings from JamesEdition
- [Auction.com Property Scraper](https://apify.com/parseforge/auction-com-property-scraper) — Collect property auction listings with bid data
- [BizBuySell Scraper V2](https://apify.com/parseforge/bizbuysell-scraper-v2) — Extract business-for-sale listings and financial data
- [Loopnet Scraper](https://apify.com/parseforge/loopnet-scraper) — Commercial real estate listings from LoopNet

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 10 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by SeLoger.com or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

Direct SeLoger.com search URL to scrape. If provided, city and transactionType are ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `transactionType` (type: `string`):

Type of real estate transaction to search for

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

City slug with department code (e.g. paris-75, lyon-69, marseille-13)

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

Residential proxy required on Apify cloud. SeLoger blocks datacenter IPs.

## Actor input object example

```json
{
  "startUrl": "https://www.seloger.com/immobilier/achat/immo-paris-75/",
  "maxItems": 10,
  "transactionType": "achat",
  "city": "paris-75",
  "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 = {
    "startUrl": "https://www.seloger.com/immobilier/achat/immo-paris-75/",
    "maxItems": 10,
    "city": "paris-75",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "startUrl": "https://www.seloger.com/immobilier/achat/immo-paris-75/",
    "maxItems": 10,
    "city": "paris-75",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "startUrl": "https://www.seloger.com/immobilier/achat/immo-paris-75/",
  "maxItems": 10,
  "city": "paris-75",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/seloger-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger.com French Real Estate Scraper",
        "description": "Scrape French real estate listings from SeLoger.com — apartments, houses, studios and more. Extract price, surface area, rooms, bedrooms, DPE/GES energy ratings, agency info, images and 20+ structured fields. Perfect for investors analyzing the French property market.",
        "version": "0.0",
        "x-build-id": "3vNiahPiZ1dIoxbQP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~seloger-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~seloger-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~seloger-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct SeLoger.com search URL to scrape. If provided, city and transactionType are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "transactionType": {
                        "title": "Transaction Type",
                        "enum": [
                            "achat",
                            "locations"
                        ],
                        "type": "string",
                        "description": "Type of real estate transaction to search for",
                        "default": "achat"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City slug with department code (e.g. paris-75, lyon-69, marseille-13)"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy required on Apify cloud. SeLoger blocks datacenter IPs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```