# SeLoger Scraper 🇫🇷 : Téléphone Vendeur, Particulier/Agence (`tagadanar/french-real-estate-seloger`) Actor

Jusqu'à 2 500 annonces SeLoger par recherche avec le téléphone du vendeur et le badge particulier/agence, plus prix, €/m² et surface. Fonctionne même quand les scrapers classiques sont bloqués. Payez à l'annonce.

- **URL**: https://apify.com/tagadanar/french-real-estate-seloger.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Real estate, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 🇫🇷 (Phone + Particulier/Agence + €/m²)

**Scrape property listings from [SeLoger](https://www.seloger.com), France's largest real-estate portal, and get the one thing other SeLoger scrapers don't give you: the seller's phone number *and* whether it's a private owner or an agency.** Paste a search URL and get up to **2,500 clean, structured listings**, each with **price, €/m², surface, rooms, location, features, seller phone**, and a **particulier-vs-agence** flag.

Built for **lead generation (pige), market analysis, property search, and AI agents** (API + MCP out of the box).

> **Why this one?** SeLoger hides the contact number behind an "Afficher le numéro" click, so most scrapers return no phone at all, or only an agency's. This actor reads the **seller phone** directly and flags **private owners vs agencies**, so you can filter to owner-direct listings and call them. No other single-portal SeLoger actor pairs those two.

### Why this actor

- ✅ **Rich, structured data**: price, €/m², surface, rooms, bedrooms, city, district, postal code, features and photos, all parsed into clean fields instead of scraped from fragile HTML.
- ✅ **Seller phone + private/agency flag**: every listing carries the advertiser's phone number and shows whether it's a **private seller (particulier)** or an agency, so you can filter to owner-direct listings with one switch.
- ✅ **Paste-a-search simplicity**: build any search on seloger.com (city, buy/rent, type, filters), then paste the URL. All result pages get followed automatically.
- ✅ **Extra filtering** lets you narrow further by price, surface, rooms, property type, keywords or private-seller-only, on top of what the search URL already selects.
- ✅ **Reliable**: it reads SeLoger's own structured data payload rather than scraping brittle DOM, through a real browser and residential proxies, so results stay complete and consistent.

### Use cases

- **Lead generation**: pull owner-direct listings with phone numbers in your target area (`onlyPrivateSeller: true`).
- **Market analysis**: compare asking prices and €/m² across a city or neighbourhood, ready to drop into a spreadsheet or BI tool.
- **Property search**: re-run a saved search on an Apify Schedule and feed listings straight into a sheet or CRM. For a **new-listings-only** feed with cross-run memory and Slack alerts, use our [Pige Immobilière bundle](https://apify.com/tagadanar/french-real-estate-pige).
- **AI agents**: plug into Claude / Cursor via MCP and ask *"3-bedroom apartments in Marseille 6e under €400k with a terrace."*

### Input

```json
{
    "searchUrls": [
        "https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\"inseeCodes\":[130055]}]"
    ],
    "onlyPrivateSeller": false,
    "minPrice": 150000,
    "maxPrice": 400000,
    "minSurface": 40,
    "minRooms": 3,
    "propertyTypes": ["Appartement"],
    "keywords": ["terrasse"],
    "maxResults": 500
}
````

**How to get a search URL:** go to [seloger.com](https://www.seloger.com), run the search you want (choose city, *acheter* or *louer*, property type, and any filters), then copy the address-bar URL and paste it into `searchUrls`. You can pass several URLs at once.

### Output (one record per listing)

```json
{
    "source": "SeLoger",
    "id": "267827001",
    "url": "https://www.seloger.com/annonces/achat/appartement/marseille-6eme-13/vauban/267827001.htm",
    "transactionType": "sale",
    "propertyType": "Appartement",
    "propertySubType": "Appartement",
    "price": 360000,
    "currency": "EUR",
    "pricePerM2": 5294,
    "rooms": 3,
    "bedrooms": 2,
    "surface": 68,
    "city": "Marseille 6ème",
    "district": "Vauban",
    "postalCode": "13006",
    "description": "Appartement à vendre - Idéalement placé, au calme…",
    "features": ["Terrasse", "Parking", "Ascenseur"],
    "photos": ["https://v.seloger.com/s/crop/800x600/visuels/1/n/l/y/…jpg"],
    "seller": "Professionnel",
    "isPrivateSeller": false,
    "contactName": "MATERRASSEAMARSEILLE.COM",
    "phone": "06 12 99 51 24",
    "hasEmail": true,
    "isExclusive": true
}
```

### Companion actors

- [**Logic-Immo Scraper**](https://apify.com/tagadanar/french-real-estate-logicimmo) covers the sister portal's listings, with the advertiser's phone number and agency/private flag.
- [**PAP Real Estate Listings**](https://apify.com/tagadanar/french-real-estate-pap) pulls owner-direct (particulier) listings from PAP.
- [**French Real Estate Sales (DVF)**](https://apify.com/tagadanar/french-real-estate-dvf): official recorded **sold** prices, useful for benchmarking SeLoger asking prices against reality.
- [**Real Estate Deal Score**](https://apify.com/tagadanar/french-real-estate-deal-score) scores asking prices against DVF sold prices.

### Pricing

Pay per event, no subscription:

| Event | Price | When |
|---|---|---|
| Listing found | **$0.0015** ($1.50 / 1,000) | Per listing returned |
| Actor start | $0.00005 (≈ zero) | Once per run |

Apify platform usage (compute + Residential proxy) is billed separately at platform rates. You control total spend with a per-run charge cap.

### FAQ

**What's the source?** Public listings on seloger.com, France's largest property portal.

**Sales and rentals?** Both. The actor detects buy vs rent from the search URL (`projects=2` = buy, `projects=1` = rent); €/m² is provided for both when available.

**Can I get only private sellers?** Yes, set `onlyPrivateSeller: true` to drop agency listings and keep owner-direct ads (with phone numbers).

**How many results can I get per search?** SeLoger lets you page through up to **2,500 results** per search, so split a large area into several searches (by arrondissement, price band, etc.) to go beyond that.

**Why is `hasEmail` a boolean?** SeLoger exposes only whether an email contact channel exists, not the address itself; the phone number is provided in full.

**Does it work with AI agents?** Yes, it's exposed via REST API and **MCP**, callable as a tool from Claude, Cursor & co.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More French real estate Actors (pige, DVF, deal score, DPE leads) are on [my profile](https://apify.com/tagadanar).

*Keywords: SeLoger, immobilier, annonces immobilières, real estate France, property listings, prix immobilier, €/m², vente appartement, location maison, seller phone, lead generation, particulier, agence immobilière, proptech.*

# Actor input Schema

## `searchUrls` (type: `array`):

One or more seloger.com search-result URLs. Build the search on <a href='https://www.seloger.com' target='_blank'>seloger.com</a> (city, buy/rent, property type, price/surface filters), then copy the page URL and paste it here. All result pages are followed automatically. Example: <code>https://www.seloger.com/list.htm?projects=2\&types=1,2\&places=\[{"inseeCodes":\[130055]}]</code>

## `onlyPrivateSeller` (type: `boolean`):

Keep only listings posted by private sellers (particuliers), dropping agency listings. Great for owner-direct lead sourcing.

## `minPrice` (type: `integer`):

Keep only listings at or above this price.

## `maxPrice` (type: `integer`):

Keep only listings at or below this price.

## `minSurface` (type: `integer`):

Keep only listings with at least this built surface.

## `minRooms` (type: `integer`):

Keep only listings with at least this many rooms (pièces).

## `propertyTypes` (type: `array`):

Keep only these property types. Empty = all types found in the search.

## `keywords` (type: `array`):

Keep only listings whose description, title, location or features contain at least one of these words (e.g. <code>terrasse</code>, <code>jardin</code>, <code>ascenseur</code>).

## `maxResults` (type: `integer`):

Stop after this many listings across all search URLs. SeLoger allows paging through at most 2,500 results per search.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\"inseeCodes\":[130055]}]&enterprise=0&qsVersion=1.0"
  ],
  "onlyPrivateSeller": false,
  "propertyTypes": [],
  "keywords": [],
  "maxResults": 50
}
```

# Actor output Schema

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

All scraped SeLoger listings (one item per property) in the default dataset.

# 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 = {
    "searchUrls": [
        "https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\"inseeCodes\":[130055]}]&enterprise=0&qsVersion=1.0"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/french-real-estate-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 = {
    "searchUrls": ["https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\"inseeCodes\":[130055]}]&enterprise=0&qsVersion=1.0"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/french-real-estate-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 '{
  "searchUrls": [
    "https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\\"inseeCodes\\":[130055]}]&enterprise=0&qsVersion=1.0"
  ],
  "maxResults": 50
}' |
apify call tagadanar/french-real-estate-seloger --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Scraper 🇫🇷 : Téléphone Vendeur, Particulier/Agence",
        "description": "Jusqu'à 2 500 annonces SeLoger par recherche avec le téléphone du vendeur et le badge particulier/agence, plus prix, €/m² et surface. Fonctionne même quand les scrapers classiques sont bloqués. Payez à l'annonce.",
        "version": "0.1",
        "x-build-id": "a5BRKwFEbE5maIBVb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~french-real-estate-seloger/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-french-real-estate-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/tagadanar~french-real-estate-seloger/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-french-real-estate-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/tagadanar~french-real-estate-seloger/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-french-real-estate-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": [
                    "searchUrls"
                ],
                "properties": {
                    "searchUrls": {
                        "title": "SeLoger search URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more seloger.com search-result URLs. Build the search on <a href='https://www.seloger.com' target='_blank'>seloger.com</a> (city, buy/rent, property type, price/surface filters), then copy the page URL and paste it here. All result pages are followed automatically. Example: <code>https://www.seloger.com/list.htm?projects=2&types=1,2&places=[{\"inseeCodes\":[130055]}]</code>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyPrivateSeller": {
                        "title": "Owner-direct only (no agencies)",
                        "type": "boolean",
                        "description": "Keep only listings posted by private sellers (particuliers), dropping agency listings. Great for owner-direct lead sourcing.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or above this price."
                    },
                    "maxPrice": {
                        "title": "Maximum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or below this price."
                    },
                    "minSurface": {
                        "title": "Minimum surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this built surface."
                    },
                    "minRooms": {
                        "title": "Minimum rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this many rooms (pièces)."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Keep only these property types. Empty = all types found in the search.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Appartement",
                                "Maison",
                                "Terrain",
                                "Immeuble",
                                "Local commercial",
                                "Bureau",
                                "Parking / Box"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House",
                                "Land",
                                "Building",
                                "Commercial",
                                "Office",
                                "Parking / Box"
                            ]
                        },
                        "default": []
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keep only listings whose description, title, location or features contain at least one of these words (e.g. <code>terrasse</code>, <code>jardin</code>, <code>ascenseur</code>).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 2500,
                        "type": "integer",
                        "description": "Stop after this many listings across all search URLs. SeLoger allows paging through at most 2,500 results per search.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```