# SeLoger Immobilier Scraper (`ahmed_hrid/seloger-immobilier-scraper`) Actor

- **URL**: https://apify.com/ahmed\_hrid/seloger-immobilier-scraper.md
- **Developed by:** [Ahmed hrid](https://apify.com/ahmed_hrid) (community)
- **Categories:** Lead generation, Real estate, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## SeLoger Scraper — Extrayez des annonces immobilières en masse

> Récupérez automatiquement des milliers d'annonces immobilières depuis SeLoger.com — prix, surface, DPE, coordonnées GPS, photos, agences — sans effort technique, en quelques clics.

**Idéal pour :** les agents immobiliers, les investisseurs, les data analysts, les chercheurs de marché et les développeurs qui ont besoin de données immobilières françaises structurées et fraîches.

---

### 📌 Ce que fait cet Actor

Le **SeLoger Scraper** extrait automatiquement les annonces immobilières publiées sur [SeLoger.com](https://www.seloger.com), le premier portail immobilier français.

Il prend en charge les deux formats d'URL de SeLoger :
- `/list.htm` — l'ancien format (recherche classique)
- `/classified-search` — le nouveau format de recherche

Pour chaque annonce, il récupère toutes les données disponibles : prix, surface, nombre de pièces, DPE, description complète, photos, coordonnées GPS et informations sur l'agence — directement depuis la source, sans contournement fragile.

**Pour qui ?**
- 🏢 **Agences immobilières** — Veille concurrentielle et analyse de marché
- 📊 **Analystes & chercheurs** — Constitution de datasets pour études de prix
- 💼 **Investisseurs** — Identification d'opportunités selon des critères précis
- 🧑‍💻 **Développeurs** — Alimentation de bases de données ou d'applications immobilières
- 📣 **Marketeurs** — Génération de leads qualifiés dans l'immobilier

---

### ✨ Fonctionnalités principales

- **Scraping multi-pages automatique** — Parcourt toutes les pages de résultats sans limite
- **Deux formats d'URL supportés** — Compatible avec les URLs `/list.htm` et `/classified-search`
- **Pages de détail enrichies** — Option pour visiter chaque annonce et récupérer description complète, DPE/GES, coordonnées GPS et galerie photo complète
- **Données structurées et propres** — Chaque annonce est normalisée dans un format JSON cohérent
- **Proxy résidentiel intégré** — Contournement fiable de la protection anti-bot DataDome via des proxies résidentiels français
- **Gestion des erreurs & retry automatique** — Backoff exponentiel sur les erreurs réseau, aucune donnée perdue
- **Limites configurables** — Contrôlez le nombre de pages et d'annonces à extraire
- **Coordonnées GPS** — Localisation précise quand l'adresse est publiée, centroïde de quartier sinon

---

### 🧠 Pourquoi cet Actor est différent

| Critère | SeLoger Scraper |
|---|---|
| Source des données | Données embarquées côté serveur (pas du DOM fragile) |
| Fiabilité | Extraction depuis la structure JSON interne — robuste aux mises à jour CSS |
| Deux formats | Ancien et nouveau format SeLoger supportés |
| DPE/GES | Classe énergétique extraite avec précision (A à G) |
| GPS | Point exact ou centroïde de zone selon la publication de l'adresse |
| Proxy | Résidentiel français par défaut — taux de succès élevé |
| Sans navigateur | Basé sur `impit` (TLS fingerprint Chrome) — rapide et économique |

---

### ⚙️ Configuration des entrées

#### Champs disponibles

| Champ | Type | Défaut | Description |
|---|---|---|---|
| `startUrls` | array | — | **Obligatoire.** URLs de recherche SeLoger à scraper |
| `maxPages` | integer | `0` | Nombre max de pages par URL (0 = illimité) |
| `maxListings` | integer | `0` | Nombre max total d'annonces (0 = illimité) |
| `scrapeDetailPages` | boolean | `false` | Visiter chaque annonce pour enrichir les données |
| `proxyConfiguration` | object | Résidentiel FR | Configuration des proxies Apify |

#### Exemple d'entrée JSON

```json
{
  "startUrls": [
    { "url": "https://www.seloger.com/list.htm?projects=2&types=2,1&natures=1&places=[{\"divisions\":[75]}]&qsVersion=1.0" },
    { "url": "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR28808&numberOfRoomsMin=2" }
  ],
  "maxPages": 5,
  "maxListings": 100,
  "scrapeDetailPages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Conseils pour construire vos URLs

1. Allez sur [SeLoger.com](https://www.seloger.com)
2. Appliquez vos filtres (ville, type de bien, budget, surface…)
3. Copiez l'URL de la page de résultats
4. Collez-la dans le champ `startUrls`

> **Astuce :** Vous pouvez passer plusieurs URLs pour scraper plusieurs villes ou types de biens en une seule exécution.

***

### 📤 Format de sortie

Chaque annonce est exportée sous forme d'objet JSON dans le dataset Apify.

#### Exemple de sortie

```json
{
  "id": "270307229",
  "url": "https://www.seloger.com/annonces/achat/appartement/courbevoie-92/270307229.htm",
  "title": "Appartement à vendre",
  "price": 450000,
  "currency": "EUR",
  "surface": 69,
  "landSurface": null,
  "rooms": 3,
  "bedrooms": 2,
  "city": "Courbevoie",
  "postalCode": "92400",
  "neighborhood": "Faubourg de l'Arche",
  "description": "Très bel appartement traversant 3 pièces de 69m²...",
  "features": ["5ème étage/9 étages", "Ascenseur", "Cave", "Balcon", "Calme"],
  "energyRating": "C",
  "greenhouseGasRating": "C",
  "agency": {
    "name": "SANS VIS A VIS COURBEVOIE",
    "address": "19 avenue Marceau, 92400 Courbevoie",
    "phone": "-- -- -- --",
    "isPrivateSeller": false,
    "agencyPage": "https://www.seloger.com/professionnels-immobilier/..."
  },
  "images": [
    "https://mms.seloger.com/9/1/6/d/916d9d61-...jpg"
  ],
  "coordinates": {
    "lat": 48.9002,
    "lng": 2.2386
  },
  "publishedAt": "2026-05-28T16:30:00Z",
  "scrapedAt": "2026-06-12T18:12:53.269Z"
}
```

#### Description des champs

| Champ | Type | Description |
|---|---|---|
| `id` | string | Identifiant unique SeLoger |
| `url` | string | URL de l'annonce |
| `title` | string | Titre de l'annonce |
| `price` | number | Prix en euros |
| `currency` | string | Toujours `"EUR"` |
| `surface` | number | Surface habitable en m² |
| `landSurface` | number|null | Surface terrain en m² (maisons uniquement) |
| `rooms` | number | Nombre de pièces |
| `bedrooms` | number | Nombre de chambres |
| `city` | string | Ville |
| `postalCode` | string | Code postal |
| `neighborhood` | string|null | Quartier ou secteur |
| `description` | string|null | Description complète de l'annonce |
| `features` | array | Équipements et caractéristiques (balcon, cave, parking…) |
| `energyRating` | string|null | Classe DPE (A à G) |
| `greenhouseGasRating` | string|null | Classe GES (A à G) |
| `agency.name` | string | Nom de l'agence ou du particulier |
| `agency.address` | string|null | Adresse de l'agence |
| `agency.phone` | string|null | Numéro de téléphone |
| `agency.isPrivateSeller` | boolean | `true` si vente entre particuliers |
| `agency.agencyPage` | string|null | Page agence sur SeLoger |
| `images` | array | URLs des photos haute résolution |
| `coordinates` | object|null | `{ lat, lng }` — coordonnées GPS |
| `publishedAt` | string|null | Date de publication ISO 8601 |
| `scrapedAt` | string | Date d'extraction ISO 8601 |

> **Note :** Les champs `description`, `energyRating`, `greenhouseGasRating`, `coordinates` et la galerie complète ne sont disponibles qu'avec `scrapeDetailPages: true`.

***

### ▶️ Comment utiliser cet Actor

#### Démarrage rapide (sans code)

1. **Ouvrez** l'Actor dans l'Apify Store
2. **Cliquez** sur "Try for free"
3. **Collez** une ou plusieurs URLs de recherche SeLoger dans le champ `startUrls`
4. **Activez** `scrapeDetailPages` si vous voulez les données complètes
5. **Lancez** l'Actor et attendez les résultats
6. **Téléchargez** vos données en JSON, CSV ou Excel

#### Via l'API Apify

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

const client = new ApifyClient({ token: 'VOTRE_TOKEN_API' });

const run = await client.actor('ACTOR_ID').call({
  startUrls: [
    { url: 'https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR75056' }
  ],
  maxListings: 200,
  scrapeDetailPages: true,
});

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

***

### 📈 Cas d'utilisation

#### 1. 🔍 Veille de marché immobilier

Suivez l'évolution des prix dans une ville ou un quartier précis. Exportez en CSV et analysez dans Excel ou Google Sheets. Planifiez des exécutions régulières pour détecter les nouvelles annonces.

#### 2. 🏗️ Génération de leads pour agences

Identifiez les biens vendus par des particuliers (`isPrivateSeller: true`) pour proposer vos services. Récupérez les numéros de téléphone et adresses d'agences.

#### 3. 📉 Analyse comparative de prix

Constituez un dataset de prix au m² par ville, type de bien et nombre de pièces. Alimentez des modèles de valorisation ou des outils d'estimation immobilière.

#### 4. 🗺️ Cartographie des annonces

Utilisez les coordonnées GPS pour afficher les biens sur une carte interactive (Mapbox, Google Maps, Leaflet).

#### 5. 📰 Alertes et monitoring automatisés

Combinez avec le scheduler Apify pour recevoir automatiquement les nouvelles annonces correspondant à vos critères — comme une alerte SeLoger, mais sans limites.

***

### 🛠️ Conseils avancés

#### Optimiser la vitesse

Désactivez `scrapeDetailPages` si vous n'avez besoin que des données de listing (prix, surface, localisation). Cela divise par deux le nombre de requêtes et réduit significativement le temps d'exécution.

#### Proxy et anti-bot

SeLoger utilise DataDome, une protection anti-bot avancée. L'Actor utilise des **proxies résidentiels français** par défaut. Gardez `apifyProxyCountry: "FR"` pour un taux de succès optimal. Les proxies datacenter seront systématiquement bloqués.

#### Scraper plusieurs villes en parallèle

```json
{
  "startUrls": [
    { "url": "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR75056" },
    { "url": "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR69123" },
    { "url": "https://www.seloger.com/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08FR13055" }
  ]
}
```

#### Export des données

Les résultats sont disponibles en **JSON**, **CSV**, **Excel**, **XML** et **RSS** directement depuis l'interface Apify ou via l'API.

***

### 🆓 Limitations du plan gratuit

| Limite | Plan gratuit | Plan payant |
|---|---|---|
| Annonces par exécution | **5 annonces max** | Illimité |
| Exécutions par jour | **5 runs/jour** (UTC) | Illimité |
| Délai entre deux runs | **30 minutes minimum** | Aucun |
| Pages de détail | ✅ Inclus | ✅ Inclus |
| Export CSV/JSON | ✅ Inclus | ✅ Inclus |

> Pour lever ces limitations, passez sur un **plan payant Apify**. Le coût est basé sur les ressources consommées (compute units), pas sur le nombre d'annonces.

***

### ❓ FAQ & Dépannage

#### L'Actor ne retourne aucun résultat

- Vérifiez que l'URL copiée retourne bien des annonces sur SeLoger.com directement dans votre navigateur
- Assurez-vous que les proxies résidentiels sont activés (`useApifyProxy: true`)
- Certaines recherches très filtrées peuvent avoir 0 résultats — élargissez vos critères

#### Je reçois des erreurs 403 ou 429

Ces erreurs signifient que SeLoger bloque les requêtes. Activez impérativement les **proxies résidentiels** avec `apifyProxyCountry: "FR"`. Les proxies datacenter sont détectés et bloqués par DataDome.

#### Les champs description, DPE et GPS sont vides

Ces champs ne sont disponibles qu'en activant `scrapeDetailPages: true`. Sans cette option, seules les données visibles sur la page de listing sont extraites.

#### Le format d'URL ne fonctionne pas

L'Actor supporte deux formats :

- `https://www.seloger.com/list.htm?...`
- `https://www.seloger.com/classified-search?...`

Les URLs de pages de détail individuelles (`/annonces/...`) ne sont pas des points d'entrée valides — utilisez des URLs de recherche.

#### Comment planifier des scrapes réguliers ?

Dans l'interface Apify, cliquez sur **"Schedule"** pour configurer des exécutions automatiques (toutes les heures, tous les jours, etc.). Idéal pour suivre l'évolution d'un marché dans le temps.

***

### 💡 Suggestions pour augmenter les conversions

> *Note interne :*
>
> - **Renommer l'Actor** `seloger-real-estate-scraper-france` pour mieux cibler les recherches Google en anglais (le marché Apify est international)
> - **Ajouter un GIF de démo** montrant l'extraction en direct dans l'Apify Console — réduit fortement la friction à l'essai
> - **Mettre en avant le champ `coordinates`** dans le titre ou le sous-titre : c'est un différenciateur fort que peu de scrapers proposent
> - **Créer des templates d'input** préremplis pour Paris, Lyon, Marseille — un clic pour démarrer
> - **Publier un dataset sample** (50 annonces réelles) en accès libre — augmente la confiance avant l'achat
> - **Ajouter un badge "Mis à jour YYYY-MM"** dans la description pour signaler la maintenance active

***

### 📞 Support

Une question ? Un bug ? Une demande de fonctionnalité ?

- 📧 **Email :** <me@ahmedhrid.com>
- 🐛 **Signaler un bug :** Utilisez le bouton "Issues" sur la page de l'Actor dans l'Apify Store
- 💬 **Communauté Apify :** [discord.gg/jyEM2PRvMU](https://discord.gg/jyEM2PRvMU)

***

*Cet Actor est maintenu activement. Si SeLoger modifie sa structure de données, une mise à jour est déployée dans les plus brefs délais.*

# Actor input Schema

## `startUrls` (type: `array`):

SeLoger search URLs to scrape. Supports both /list.htm (legacy) and /classified-search (new) formats.

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

Maximum number of result pages to scrape per start URL. 0 = no limit.

## `maxListings` (type: `integer`):

Maximum total number of listings to extract across all start URLs. 0 = no limit.

## `scrapeDetailPages` (type: `boolean`):

If true, follow each listing URL to extract full description, coordinates, DPE, and agency details. Doubles request count — disable for fast bulk extraction.

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

Residential proxies are strongly recommended. SeLoger uses DataDome anti-bot protection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.seloger.com/classified-search?classifiedBusiness=Private&distributionTypes=Buy,Buy_Auction&estateTypes=House,Apartment&locations=AD08FR1977&priceMax=300000&priceMin=100000&order=DateDesc&m=classifed_search_results_map_switch_button_to_classified_search_results"
    }
  ],
  "maxPages": 0,
  "maxListings": 0,
  "scrapeDetailPages": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

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

Dataset containing scraped listings with details, pricing, location, and contact information

# 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 = {
    "startUrls": [
        {
            "url": "https://www.seloger.com/classified-search?classifiedBusiness=Private&distributionTypes=Buy,Buy_Auction&estateTypes=House,Apartment&locations=AD08FR1977&priceMax=300000&priceMin=100000&order=DateDesc&m=classifed_search_results_map_switch_button_to_classified_search_results"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_hrid/seloger-immobilier-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 = {
    "startUrls": [{ "url": "https://www.seloger.com/classified-search?classifiedBusiness=Private&distributionTypes=Buy,Buy_Auction&estateTypes=House,Apartment&locations=AD08FR1977&priceMax=300000&priceMin=100000&order=DateDesc&m=classifed_search_results_map_switch_button_to_classified_search_results" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_hrid/seloger-immobilier-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 '{
  "startUrls": [
    {
      "url": "https://www.seloger.com/classified-search?classifiedBusiness=Private&distributionTypes=Buy,Buy_Auction&estateTypes=House,Apartment&locations=AD08FR1977&priceMax=300000&priceMin=100000&order=DateDesc&m=classifed_search_results_map_switch_button_to_classified_search_results"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call ahmed_hrid/seloger-immobilier-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Immobilier Scraper",
        "version": "0.0",
        "x-build-id": "oct2bvE2ISfKpmH9g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ahmed_hrid~seloger-immobilier-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ahmed_hrid-seloger-immobilier-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/ahmed_hrid~seloger-immobilier-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ahmed_hrid-seloger-immobilier-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/ahmed_hrid~seloger-immobilier-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ahmed_hrid-seloger-immobilier-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "SeLoger search URLs to scrape. Supports both /list.htm (legacy) and /classified-search (new) formats.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPages": {
                        "title": "Max pages per start URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of result pages to scrape per start URL. 0 = no limit.",
                        "default": 0
                    },
                    "maxListings": {
                        "title": "Max total listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of listings to extract across all start URLs. 0 = no limit.",
                        "default": 0
                    },
                    "scrapeDetailPages": {
                        "title": "Scrape detail pages",
                        "type": "boolean",
                        "description": "If true, follow each listing URL to extract full description, coordinates, DPE, and agency details. Doubles request count — disable for fast bulk extraction.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended. SeLoger uses DataDome anti-bot protection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
