# 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:** 11 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.70 / 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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏠 SeLoger.com French Real Estate Scraper

> 🚀 **Collect French property listings with energy ratings and price per m2.** Search apartments, houses, and studios across France. Extract prices, surface areas, DPE/GES classes, agency info, and image galleries. No coding required.

> 🕒 **Last updated:** 2026-04-16 · **📊 24 fields** per listing · **⚡ DPE/GES energy ratings** · **💰 Price per m2** calculated · **🏠 Buy + rent** support

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

Whether you are a real estate investor analyzing the French property market, a relocation agency helping clients find homes in France, or a data analyst tracking property trends across cities, this tool collects structured French real estate data without manual browsing.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Real estate investors, relocation agencies, market researchers, property analysts, portfolio managers | Property price tracking, market analysis, relocation research, energy efficiency analysis, investment screening |

---

### 📋 What the SeLoger Scraper does

- 💰 **Price and price per m2.** Track property prices with automatically calculated price per square meter for value comparisons.
- 🏢 **Property types.** Identify apartments, houses, studios, and other property categories.
- 📐 **Surface area.** Collect exact living area in square meters.
- 🛏️ **Rooms and bedrooms.** Count total rooms and bedrooms for each listing.
- ⚡ **DPE and GES energy ratings.** Get official French energy performance classes (A-G) for consumption and greenhouse gas emissions.
- 🖼️ **Image galleries.** Collect all property photos from each listing.

Each record includes agency name, floor level, neighborhood, postal code, and transaction type.

> 💡 **Why it matters:** manually browsing French property listings to compare prices, energy ratings, and locations across cities takes hours. This Actor exports structured real estate data with calculated metrics ready for analysis.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>startUrl</td><td>string</td><td>Paris achat URL</td><td>Direct SeLoger search URL (overrides city/transaction).</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Max listings. Free: 10, Paid: up to 1,000,000.</td></tr>
<tr><td>transactionType</td><td>string</td><td>"achat"</td><td>Buy (achat) or rent (locations).</td></tr>
<tr><td>city</td><td>string</td><td>"paris-75"</td><td>City slug with department code (e.g., lyon-69).</td></tr>
<tr><td>proxyConfiguration</td><td>object</td><td>Residential</td><td>Proxy settings. Residential recommended.</td></tr>
</tbody>
</table>

**Example: buy properties in Paris.**

```json
{
    "transactionType": "achat",
    "city": "paris-75",
    "maxItems": 50
}
````

**Example: rental listings in Lyon.**

```json
{
    "transactionType": "locations",
    "city": "lyon-69",
    "maxItems": 25
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 items per run. Residential proxy is recommended for large-scale collection. Use city slug format with department code (e.g., paris-75, marseille-13, bordeaux-33).

***

### 📊 Output

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔗 listingUrl | string | `"https://www.seloger.com/annonces/123456789.htm"` |
| 🆔 listingId | string | `"123456789"` |
| 🖼️ imageUrl | string | `"https://mms.seloger.com/img/photo.jpg"` |
| 🏢 propertyType | string | `"Appartement"` |
| 💰 price | number | `485000` |
| 💰 pricePerM2 | number | `9699` |
| 🛏️ rooms | number | `3` |
| 🛏️ bedrooms | number | `2` |
| 📐 surfaceM2 | number | `50` |
| 🏢 floor | string | `"2eme etage"` |
| 📍 neighborhood | string | `"Montmartre"` |
| 🏙️ city | string | `"Paris"` |
| 📮 postalCode | string | `"75018"` |
| 📝 description | string | Property description |
| ⚡ dpeClass | string | `"C"` |
| ⚡ gesClass | string | `"D"` |
| 🔥 heatingType | string | Type of heating |
| 📋 features | string | Property features |
| 💼 agencyName | string | `"Agence Parisienne"` |
| 🖼️ images | array | All property photos |
| 🏗️ isNewBuild | boolean | false |
| 📋 transactionType | string | `"Buy"` |
| 🕒 scrapedAt | ISO 8601 | `"2026-04-07T12:00:00.000Z"` |
| ⚠️ error | string | Error message if any |

#### 📦 Sample records

<details><summary><strong>🏠 Paris apartment with full data</strong></summary>

```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": "2eme etage",
    "neighborhood": "Montmartre",
    "city": "Paris",
    "postalCode": "75018",
    "dpeClass": "C",
    "gesClass": "D",
    "agencyName": "Agence Parisienne",
    "isNewBuild": false,
    "transactionType": "Buy",
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

</details>

<details><summary><strong>🏡 Lyon house listing</strong></summary>

```json
{
    "listingUrl": "https://www.seloger.com/annonces/987654321.htm",
    "listingId": "987654321",
    "imageUrl": "https://mms.seloger.com/img/house.jpg",
    "propertyType": "Maison",
    "price": 350000,
    "pricePerM2": 3500,
    "rooms": 5,
    "bedrooms": 3,
    "surfaceM2": 100,
    "floor": null,
    "neighborhood": "Croix-Rousse",
    "city": "Lyon",
    "postalCode": "69004",
    "dpeClass": "B",
    "gesClass": "A",
    "agencyName": "Lyon Immobilier",
    "isNewBuild": false,
    "transactionType": "Buy",
    "scrapedAt": "2026-04-07T12:05:00.000Z"
}
```

</details>

<details><summary><strong>🏢 Studio rental in Marseille</strong></summary>

```json
{
    "listingUrl": "https://www.seloger.com/annonces/555444333.htm",
    "listingId": "555444333",
    "imageUrl": "https://mms.seloger.com/img/studio.jpg",
    "propertyType": "Studio",
    "price": 650,
    "pricePerM2": 32,
    "rooms": 1,
    "bedrooms": 0,
    "surfaceM2": 20,
    "floor": "4eme etage",
    "neighborhood": "Vieux-Port",
    "city": "Marseille",
    "postalCode": "13001",
    "dpeClass": "E",
    "gesClass": "F",
    "agencyName": "Marseille Location",
    "isNewBuild": false,
    "transactionType": "Rent",
    "scrapedAt": "2026-04-07T12:10:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| ⚡ | **Energy ratings.** DPE and GES classes (A-G) for every listing. |
| 💰 | **Price per m2.** Automatically calculated for instant value comparison. |
| 🖼️ | **Image galleries.** All property photos collected per listing. |
| 💼 | **Agency info.** Listing agency name for every property. |
| 🏗️ | **New build detection.** Flags new construction properties. |
| 🏠 | **Buy and rent.** Both transaction types supported. |
| 📊 | **24 structured fields.** Full property data ready for analysis. |

> 📊 **24 fields per listing** with DPE/GES energy classes, price per m2, agency data, and image galleries.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Energy data | Price per m2 | Setup |
|---|---|---|---|---|---|
| **⭐ SeLoger Scraper** *(this Actor)* | $5 free credit | All French cities | DPE + GES classes | Auto-calculated | ⚡ 2 min |
| Manual browsing | Free | One at a time | Visual only | Manual math | 🕒 Hours |
| Generic web scraper | Varies | Requires setup | Not extracted | Not calculated | 🕒 30+ min |
| Other property scrapers | Varies | Varies | Rarely included | Rarely included | 🕒 Varies |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the SeLoger Scraper page on Apify.
3. 🎯 **Set input.** Choose a city (e.g., paris-75) and transaction type (buy or rent).
4. 🚀 **Run it.** Click **Start** and watch results appear.
5. 📥 **Download.** Grab results in JSON, CSV, or Excel from the **Dataset** tab.

> ⏱️ Total time: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr><td width="50%" valign="top">

#### 💰 Investment & Analysis

- Monitor property prices across French cities
- Identify undervalued neighborhoods by price per m2
- Track energy efficiency trends (DPE/GES)
- Build market reports with structured data

</td><td width="50%" valign="top">

#### 🏠 Relocation & Research

- Collect properties matching client criteria daily
- Compare rental costs across neighborhoods
- Analyze supply and pricing by property type
- Track new construction availability

</td></tr>
</table>

***

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20SeLoger.com%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20SeLoger.com%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20SeLoger.com%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20SeLoger.com%20French%20Real%20Estate%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

### ❓ Frequently Asked Questions

<details>
<summary><b>💳 Do I need a paid Apify plan to run this actor?</b></summary>

No. You can start right now on the free Apify plan, which includes **$5 in free monthly credit**. That is enough to run this actor several times and explore the output before committing to anything. Paid plans unlock higher limits, more concurrent runs, and larger datasets. [Create a free Apify account here](https://console.apify.com/sign-up?fpr=vmoqkp) to get started.

</details>

<details>
<summary><b>🚨 What happens if my run fails or returns no results?</b></summary>

Failed runs are not charged. If the source site changes, proxies get rate-limited, or a specific input matches nothing, re-run the actor or open our [contact form](https://tally.so/r/BzdKgA) and we will investigate. You can also check the run log in the Apify console to see why the run stopped.

</details>

<details>
<summary><b>📏 How many items can I scrape per run?</b></summary>

Free users are limited to **10 items per run** so you can preview the output and confirm the actor works for your use case. Paid users can raise maxItems up to **1,000,000** per run. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) if you need full scale.

</details>

<details>
<summary><b>🕒 How fresh is the data?</b></summary>

Every run fetches live data at the moment of execution. There is no cache or delay: the records you get reflect what the source returned at that moment. Schedule the actor to maintain a rolling snapshot of the data you need.

</details>

<details>
<summary><b>🧑‍💻 Can I call this actor from my own code?</b></summary>

Yes. Apify exposes every actor as a REST endpoint and ships first-class SDKs for [Node.js](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python). You can start a run, read the dataset, and handle webhooks from your own app in a few lines. All you need is your Apify API token.

</details>

<details>
<summary><b>📤 How do I export the data?</b></summary>

Every Apify dataset can be downloaded in one click from the console as CSV, JSON, JSONL, Excel, HTML, XML, or RSS. You can also pull results programmatically via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, and other destinations through built-in integrations.

</details>

<details>
<summary><b>📅 Can I schedule the actor to run automatically?</b></summary>

Yes. Use the Apify scheduler to run the actor on any cadence, from hourly to monthly. Results are saved to your dataset and can be delivered to webhooks, email, Slack, cloud storage, or automation tools such as Zapier and Make.

***

</details>

### 🔌 Automating SeLoger Scraper

- 🟢 **Node.js.** Install the apify-client NPM package.
- 🐍 **Python.** Use the apify-client PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

### 🔌 Integrate with any app

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate property monitoring workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notifications for new listings
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export to Sheets

***

### 🔗 Recommended Actors

- [**🏘️ James Edition Scraper**](https://apify.com/parseforge/james-edition-real-estate-scraper) - Luxury real estate listings
- [**🏠 Auction.com Scraper**](https://apify.com/parseforge/auction-com-property-scraper) - Property auctions
- [**💼 BizBuySell Scraper V2**](https://apify.com/parseforge/bizbuysell-scraper-v2) - Business-for-sale listings
- [**🏢 LoopNet Scraper**](https://apify.com/parseforge/loopnet-scraper) - Commercial real estate
- [**🏡 LandWatch Scraper**](https://apify.com/parseforge/landwatch-scraper) - Rural land and property

> 💡 Browse the complete [ParseForge collection](https://apify.com/parseforge).

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper or report an issue.

***

> **⚠️ Disclaimer:** Independent tool, not affiliated with SeLoger.com or any of its subsidiaries. Only publicly available data is collected.

# 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"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "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": "1aOBGd2gyZ5kWj4JI"
    },
    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
