# SeLoger Scraper (`data_forge_org/apify-seloger`) Actor

Récupérez les annonces immobilières de SeLoger : appartements, maisons, locations, prix, surfaces, pièces, DPE/GES, photos, contacts d'agences et détails complets, avec une tarification à l'usage.

- **URL**: https://apify.com/data\_forge\_org/apify-seloger.md
- **Developed by:** [Data Forge](https://apify.com/data_forge_org) (community)
- **Categories:** Real estate, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 annonces

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

## Scraper SeLoger

Extrayez les annonces immobilières de [SeLoger.com](https://www.seloger.com) avec un scraper rapide, fiable et simple à utiliser. Cet Actor Apify permet de récupérer les résultats de recherche, les prix, surfaces, pièces, DPE, photos, agences et, si besoin, les détails complets de chaque annonce.

Sa particularité : une **tarification à l’usage**, pour ne payer que les données réellement extraites.

---

### Pourquoi utiliser ce scraper SeLoger ?

- **Extraction rapide des résultats de recherche** — scrape une ou plusieurs pages de résultats SeLoger.
- **Données détaillées en option** — enrichit chaque annonce avec les informations de la page détail : DPE, GES, photos, agent, mensualité estimée, référence agence, etc.
- **Tarification à l’usage** — vous payez selon le volume réellement extrait, sans forfait inutile.
- **Simple à intégrer** — utilisable depuis l’interface Apify, l’API Apify ou vos automatisations.
- **Pensé pour des usages concrets** — veille immobilière, analyse de marché, enrichissement de données et suivi concurrentiel.

---

### Cas d’usage

#### Veille immobilière
Surveillez les nouvelles annonces, les baisses de prix et les biens concurrents sur une zone géographique donnée.

#### Agences immobilières
Analysez l’offre visible sur SeLoger pour mieux suivre votre marché local.

#### Investissement immobilier
Filtrez les annonces selon le prix, la surface, le nombre de pièces ou les performances énergétiques.

#### Outils et automatisations
Alimentez un CRM, un tableau de bord, une base interne ou un moteur d’alertes avec des données SeLoger structurées.

---

### Données extraites

#### Annonces depuis les pages de résultats

| Champ | Description |
|---|---|
| `url` | URL de l'annonce |
| `annonce_id` | Identifiant SeLoger |
| `site` | `SeLoger` ou `Belles Demeures` |
| `transaction` | `achat` ou `location` |
| `type_bien` | Type de bien |
| `prix` | Prix en € |
| `surface_m2` | Surface habitable en m² |
| `nb_pieces` | Nombre de pièces |
| `etage` | Étage |
| `agence` | Nom de l'agence |
| `ville` | Ville |
| `code_postal` | Code postal |
| `dpe` | Classe DPE (A-G) |

#### Détails complets de l’annonce

Si `include_details` est activé, des champs supplémentaires sont extraits depuis la page détail :

| Champ | Description |
|---|---|
| `id_interne` | Identifiant interne SeLoger |
| `titre_annonce` | Titre de l'annonce |
| `description` | Description complète |
| `date_creation` | Date de publication |
| `photos` | Liste des photos `[{url, type}]` |
| `dpe_classe` | Classe DPE |
| `ges_classe` | Classe GES |
| `type_chauffage` | Type de chauffage |
| `mensualite_estimee` | Mensualité estimée |
| `charges_copro_eur` | Charges annuelles de copropriété |
| `reference_annonce` | Référence de l’annonce |
| `nom_agent` | Nom du conseiller |

---

### Paramètres d’entrée

| Champ | Type | Défaut | Description |
|---|---|---|---|
| `transaction` | `achat` \| `location` | `achat` | Type de transaction |
| `prop_type` | `appartement` \| `maison` \| `terrain` | `appartement` | Type de bien |
| `city_slug` | chaîne | `paris-75` | Ville ciblée, par exemple `lyon-69` |
| `max_price` | entier | — | Prix maximum en € |
| `min_surface` | entier | — | Surface minimale en m² |
| `nb_pages` | entier (1-10) | `1` | Nombre de pages de résultats à scraper |
| `include_details` | booléen | `false` | Active l’extraction des pages détail |

---

### Exemple d’entrée

```json
{
  "transaction": "achat",
  "prop_type": "appartement",
  "city_slug": "paris-75",
  "max_price": 600000,
  "min_surface": 35,
  "nb_pages": 3,
  "include_details": true
}
````

***

### Exemple de sortie

```json
{
  "url": "https://www.seloger.com/annonces/achat/appartement/paris-75/270317887.htm",
  "annonce_id": "270317887",
  "site": "SeLoger",
  "transaction": "achat",
  "type_bien": "Appartement",
  "prix": 598000,
  "surface_m2": 58,
  "nb_pieces": 3,
  "agence": "Nom Agence",
  "ville": "Paris",
  "code_postal": "75011",
  "dpe": "E",
  "titre_annonce": "Appartement 3 pièces de 58m²",
  "dpe_classe": "E",
  "ges_classe": "B",
  "nom_agent": "Laura Nahon"
}
```

***

### Tarification

Ce scraper SeLoger fonctionne avec une **tarification à l’usage** : vous payez uniquement les événements réellement consommés.

| Événement | Prix |
|---|---|
| Démarrage de l'Actor (`apify-actor-start`) | **$0,003 / démarrage** |
| Annonce récupérée (`listing-scraped`) | **$1,50 / 1 000 annonces** |
| Détails complets (`detail-scraped`) | **$5,00 / 1 000 fiches détail** |

Ce modèle convient particulièrement bien si vous souhaitez :

- tester le scraper à faible coût ;
- maîtriser vos dépenses ;
- lancer des extractions ponctuelles ;
- payer en fonction de l’usage réel.

***

### FAQ

#### Quelle est la différence entre le mode standard et l’extraction détaillée ?

Le mode standard récupère les informations visibles depuis les pages de résultats. L’extraction détaillée ouvre chaque annonce pour obtenir davantage de champs.

#### Comment réduire les coûts ?

Limitez le nombre de pages, activez les détails uniquement si nécessaire, et ciblez précisément vos recherches selon votre besoin.

#### À quoi sert ce scraper concrètement ?

Il peut servir à la veille immobilière, à l’analyse de marché, à l’enrichissement de données, à la prospection ou à l’automatisation de workflows.

#### Quelles données peut-on récupérer ?

Les données extraites incluent notamment les URLs d’annonces, les prix, surfaces, pièces, agences, villes, codes postaux et, en option, des champs détaillés comme les DPE, GES, photos et informations d’agent.

***

### Ressources

- [Documentation API Apify](https://docs.apify.com/api/v2)
- [Intégrations Apify](https://apify.com/integrations)

***

### Support

Un bug, un besoin spécifique ou une fonctionnalité manquante ? Ouvrez un ticket directement sur la page de l’Actor.

# Actor input Schema

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

Rechercher des biens à vendre ou à louer.

## `prop_type` (type: `string`):

Type de bien immobilier à rechercher.

## `city_slug` (type: `string`):

Identifiant de ville utilisé par SeLoger, ex : paris-75, lyon-69, bordeaux-33.

## `max_price` (type: `integer`):

Prix maximum en euros. Laisser vide pour ne pas appliquer de limite.

## `min_surface` (type: `integer`):

Surface habitable minimum en m². Laisser vide pour ne pas appliquer de limite.

## `nb_pages` (type: `integer`):

Nombre de pages de résultats à scraper (environ 20 annonces par page).

## `include_details` (type: `boolean`):

Si activé, chaque annonce inclut les informations complètes : description, photos, DPE/GES, diagnostics énergétiques, informations de copropriété, etc. Facturé séparément par annonce.

## Actor input object example

```json
{
  "transaction": "achat",
  "prop_type": "appartement",
  "city_slug": "paris-75",
  "nb_pages": 1,
  "include_details": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("data_forge_org/apify-seloger").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("data_forge_org/apify-seloger").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 '{}' |
apify call data_forge_org/apify-seloger --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Scraper",
        "description": "Récupérez les annonces immobilières de SeLoger : appartements, maisons, locations, prix, surfaces, pièces, DPE/GES, photos, contacts d'agences et détails complets, avec une tarification à l'usage.",
        "version": "0.0",
        "x-build-id": "vMNjvc5uhRQaXLHWI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_forge_org~apify-seloger/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_forge_org-apify-seloger",
                "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/data_forge_org~apify-seloger/runs": {
            "post": {
                "operationId": "runs-sync-data_forge_org-apify-seloger",
                "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/data_forge_org~apify-seloger/run-sync": {
            "post": {
                "operationId": "run-sync-data_forge_org-apify-seloger",
                "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": [
                    "transaction",
                    "prop_type",
                    "city_slug"
                ],
                "properties": {
                    "transaction": {
                        "title": "Type de transaction",
                        "enum": [
                            "achat",
                            "location"
                        ],
                        "type": "string",
                        "description": "Rechercher des biens à vendre ou à louer.",
                        "default": "achat"
                    },
                    "prop_type": {
                        "title": "Type de bien",
                        "enum": [
                            "appartement",
                            "maison",
                            "terrain"
                        ],
                        "type": "string",
                        "description": "Type de bien immobilier à rechercher.",
                        "default": "appartement"
                    },
                    "city_slug": {
                        "title": "Ville (slug SeLoger)",
                        "pattern": "^[a-z0-9\\-]+$",
                        "type": "string",
                        "description": "Identifiant de ville utilisé par SeLoger, ex : paris-75, lyon-69, bordeaux-33.",
                        "default": "paris-75"
                    },
                    "max_price": {
                        "title": "Prix maximum (€)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Prix maximum en euros. Laisser vide pour ne pas appliquer de limite."
                    },
                    "min_surface": {
                        "title": "Surface minimum (m²)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Surface habitable minimum en m². Laisser vide pour ne pas appliquer de limite."
                    },
                    "nb_pages": {
                        "title": "Nombre de pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Nombre de pages de résultats à scraper (environ 20 annonces par page).",
                        "default": 1
                    },
                    "include_details": {
                        "title": "Inclure les détails complets",
                        "type": "boolean",
                        "description": "Si activé, chaque annonce inclut les informations complètes : description, photos, DPE/GES, diagnostics énergétiques, informations de copropriété, etc. Facturé séparément par annonce.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
