# SeLoger Scraper: Listings, Prices and Agencies (`automation_craft/seloger-scraper`) Actor

Scrape SeLoger property ads for sale and rent by town, postal code or filters, or paste search links, no login. Rows carry price, price per m2, surface, rooms, DPE, place, photos and the agency's name, phone and SIRET. Read agencies, monitor new ads and price changes; JSON, CSV or API.

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

## Pricing

from $0.85 / 1,000 listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### SeLoger Scraper: Listings, Prices and Agencies

**SeLoger scraper** for France's leading property portal (seloger.com): search homes, flats, plots, parking, offices and shops for
sale or rent by town, postal code or department with SeLoger's own filters, or paste SeLoger search links, and get one row per ad
with its price, price per m2, surface, rooms, energy class (DPE), place, agency name, phone and SIRET, photos and dates. Read single
ads, an agency's ads or every agency of a town. No login, no cookies, no captcha. Every search is read to its end, past SeLoger's
10,000 ads per order.

Who uses it: estate agents and property hunters watching new listings ("pige immobilière"), investors and analysts comparing
prices per m2 by district, proptech and price comparison apps, and teams building lead lists of French estate agencies.

### Quick start

1. Open the **Input** tab and type a place in **Places**, for example `Paris 18e`, `Lyon`, `33000` or `Gironde`.
2. Choose buy or rent and the property types, then add filters if you like: price, surface, rooms, bedrooms, energy class,
   features, floors, seller type, keywords.
3. Or paste one or more SeLoger search links (`https://www.seloger.com/classified-search?...`) into **SeLoger search links**.
4. Set **Maximum ads** and click **Start**. Download the rows as JSON, CSV or Excel, or read them through the Apify API.

To watch a search for new ads, give the run a **Monitor name** and schedule it: each run delivers only the ads it never delivered
before, and with **Track changes and removals** also the ads whose price changed and the ads taken offline.

### What you get

One row per ad (`type: "listing"`), one row per agency (`type: "agency"`) for agency links and the directory, one coverage row per
search (`type: "search"`), free status rows for anything that could not be delivered, and a run summary (`type: "summary"`).

| Field | What it is | Filled on (measured on 1,166 ads of the final build's runs, apartments and houses, 2026-10-18) |
|---|---|---|
| `id`, `legacyId`, `url`, `portal` | SeLoger's 12 character id, the older numeric id, the ad's link, the SeLoger site it belongs to (seloger, bellesdemeures, selogerneuf ...) | every ad |
| `transaction`, `propertyType`, `propertySubType` | buy or rent, SeLoger's property type and sub type | every ad |
| `price`, `pricePerSqm`, `currency` | the price in euros (the monthly rent for rentals) and the price per m2 | 99.7 and 98.7 percent |
| `surface`, `plotSurface`, `rooms`, `bedrooms` | living surface and plot in m2, rooms (pièces), bedrooms | surface 98.8, rooms 98.9, bedrooms 71 percent (parking and plots carry no rooms) |
| `floor`, `floorsInBuilding`, `yearBuilt` | floor, floors of the building, year built | floor 85 percent, year built 53 percent |
| `energyClass` | the DPE letter on the card | 70 percent |
| `city`, `postalCode`, `department`, `placeIds`, `transport` | where the property is, SeLoger's place codes, nearby metro and train lines (Paris) | every ad (transport 37 percent) |
| `title`, `headline`, `description`, `keyFacts` | the ad's title, headline, the card's description (the whole text with Listing details) and key facts | every ad |
| `photos`, `photoCount`, `has3DVisit` | every photo link, how many, a 3D visit | 95 percent |
| `createdAt`, `updatedAt`, `daysOnMarket` | first published, last update, whole days on the market | every ad |
| `sellerType`, `agencyName`, `agencyId`, `agencyProfileUrl`, `agencyPhones`, `agencyAddress`, `agencyWebsite` | professional or private, and the agency's public contact data | agency name 95 percent, phones 91 percent, website 45 percent |
| `agencySiret`, `agencySiren`, `agencyRcs`, `agencyLegalName`, `agencyHeadOffice` | the agency's legal identity as SeLoger shows it | SIRET 92 percent, RCS 94 percent |
| `isExclusive`, `isNew`, `hasBrokerageFee` | exclusive mandate, new build, agency fees shown | every ad |
| `searchKind`, `searchLabel`, `searchPage`, `rank` | which search, page and rank delivered the row | every row |
| `listingDetails` | with **Listing details** on: the ad's full record (below) | every ad read |
| `agencyProfile` | with **Agency profiles** on: the agency's public page (below) | agencies whose page could be read |
| `change` | on a monitor's change row: what changed, the previous price, the change in euros and percent, the price history | change rows |
| `contactName`, `privateSellerName`, `privateSellerPhones` | an agent's own name on an agency's ad; a private seller's shown name and phone numbers: only with **Include personal data** on | with the switch on |
| `teamMembers` (agency rows) | the agency's team as its page lists it: only with **Include personal data** on | with the switch on |

A sample row (shortened):

```json
{
  "type": "listing",
  "id": "26516AN5ND4S",
  "url": "https://www.seloger.com/annonce/achat/auvergne-rhone-alpes/rhone-69/lyon-69000/26516AN5ND4S",
  "transaction": "buy", "propertyType": "APARTMENT",
  "price": 295000, "pricePerSqm": 3592.74, "surface": 82.11, "rooms": 3, "bedrooms": 2, "energyClass": "C",
  "city": "Lyon 3ème arrondissement", "postalCode": "69003",
  "sellerType": "professional", "agencyName": "CHARPENNES ROLIN BAINSON", "agencyPhones": ["0478930045 / 0626462994"],
  "agencySiret": "31495098100022", "photoCount": 10,
  "createdAt": "2026-04-01T11:54:00Z", "updatedAt": "2026-10-18T00:06:15.522Z", "daysOnMarket": 199
}
```

The coverage row of each search says how many ads SeLoger holds for it (`adsOnSeLoger`), how many results pages were read, how many
ads were delivered, left out by a filter (and by which) or already delivered, whether the search was read to its end (`complete`)
and why it stopped (`stoppedBy`).

### How much does it cost to scrape SeLoger?

You pay per event, with Apify's store discounts by plan:

| Event | Free plan | Bronze | Silver | Gold |
|---|---|---|---|---|
| Listing (one ad row) | $1.19 per 1,000 | $1.08 per 1,000 | $0.98 per 1,000 | $0.85 per 1,000 |
| Listing details (add-on, per ad row that carries the full record) | $0.79 per 1,000 | $0.69 per 1,000 | $0.65 per 1,000 | $0.59 per 1,000 |
| Agency profile (per agency row; with the add-on once per agency per run) | $0.005 | $0.0045 | $0.0042 | $0.004 |
| Results page (monitor runs; a pasted link's first page read in another order) | $0.005 | $0.005 | $0.005 | $0.005 |
| Actor start (once per run) | $0.012 | $0.012 | $0.012 | $0.012 |

Platinum and Diamond plans pay the Gold price. The Actor start is a flat fee per run, with no plan discount.

The Store pricing card shows these prices per 1,000 events: "$0.85 / 1,000" on the Listing row means one ad row costs $0.00085 on
the Gold plan; "$5 / 1,000" on the Results page row means one results page costs $0.005; "$4 / 1,000" on the Agency profile row
means one agency costs $0.004 on the Gold plan.

- Never billed: ads left out by your filters, ads already delivered in the run, ads a monitor already knows, ads no longer online,
  invalid inputs, coverage rows, status rows and the summary.
- Results pages are billed in monitor runs: a monitor reads every ad updated since its last run each time, so every results page it
  reads (up to 100 ads) is billed, whatever it held. Outside a monitor, only a pasted search link's first page is billed, and only
  when it is read just to learn the search (you asked another order than the link's own, oldest first or a posted window); a link
  read in its own order delivers that page's ads instead.
- Example on the Free plan: 1,000 ads from one search cost $0.012 (start) + 1,000 listings ($1.19) = about $1.20. On the Gold plan
  the same run costs about $0.86.
- Example of a daily monitor run (Gold) that reads 3 results pages and finds 40 new ads: start ($0.012) + 3 results pages ($0.015) +
  40 listings ($0.034) = about $0.06.

### Input

| Setting | What it does |
|---|---|
| `places` | One search per place: towns (`Lyon`), arrondissements (`Paris 18e`), postal codes (`33000`), departments (`Gironde`), regions, districts, resolved through SeLoger's own place lookup. A place that matches several is a free status row naming the candidates. |
| `transaction`, `propertyTypes`, `projectTypes` | Buy or rent; apartment, house, parking, plot, building, other, office, retail, warehouse, hotel and restaurant, agricultural; resale, new build, life annuity, investment, construction project (rentals: standard, flatsharing, short term). |
| `minPrice` ... `maxYearBuilt` | Price, surface, plot surface, rooms, bedrooms and year built ranges, sent to SeLoger and checked on every row. |
| `minPricePerSqm`, `maxPricePerSqm` | Price per m2 range (SeLoger has no such filter: checked on every row). |
| `energyClasses`, `features`, `heatingTypes`, `floors`, `furnished`, `availableBefore`, `sellerType`, `needsRenovation`, `keywords` | SeLoger's own filters (DPE letters, balcony, terrace, garden, lift, pool, parking, cellar ...). |
| `postedWithinDays` or `postedWithinHours`, `minDaysOnMarket` | Only ads first published in the last N days or hours; only ads on the market for at least N days. |
| `withPhoneOnly`, `withPhotosOnly`, `excludeAdIds`, `excludeDatasetIds` | Ads with a phone number, ads with photos; ads to leave out by id or link, or every ad of your earlier datasets. |
| `sort` | Newest first (default), oldest first, relevance, price, price per m2, surface or rooms, each way. |
| `searchUrls` | SeLoger search links, read as SeLoger applies them (the search filters above do not apply to them; the row filters do). |
| `adUrls` | Single ads: links of seloger.com, Belles Demeures, SeLoger Neuf, SeLoger Bureaux & Commerces, SeLoger Construire, or ids. |
| `agencyUrls`, `includeAgencyListings` | Agency pages or ids: one agency row each and, by default, the ads its page lists. |
| `agencyDirectory` | Towns (`Bordeaux`) or SeLoger directory links: one agency row for every agency of the town. |
| `agencyNameContains`, `agencyNetwork`, `agenciesWithPhoneOnly`, `agenciesWithEmailOnly` | Filters on agency rows. |
| `maxItems`, `maxItemsPerSearch`, `maxPagesPerSearch` | Caps per run, per search, per search in results pages. |
| `includeDetails`, `includeAgencyProfiles`, `includePersonalData` | The add-ons and the personal data switch (below). |
| `monitorName`, `trackChanges`, `changeFields`, `includeUnchanged` | The monitor (below). |
| `webhookUrl`, `webhookSecret`, `telegramBotToken`, `telegramChatId` | Free notifications of the run's new rows (a webhook secret has 16 to 200 letters, digits and - \_ . ~). |
| `failIfIncomplete`, `proxyConfiguration` | Fail the run when a search could not be read to its end; Apify residential proxies (default, included in the price) or your own proxy links. |

Every filter whose field the row carries (transaction, property type, place, price, price per m2, surface, plot, rooms, bedrooms,
year built, energy class, seller type, posted date, days on market, phone, photos) is checked again on each ad before it is billed;
an ad that does not match is left out free and counted on the coverage row. Features, heating, floors, furnished, availability,
renovation, project types and keywords are applied by SeLoger alone, since no field of the result card shows them.

#### Every search to its end

SeLoger serves the first 10,000 ads of one search in one order. This Actor reads them, then goes on in price order in windows that
start at the last price read, so a search of any size is read to its end. Measured on 2026-10-18: a pasted search of Lyon and
Nantes apartments that SeLoger counted at 11,082 ads was delivered as 11,085 distinct ads in one run of 23 minutes (ads arrived
during it), and the same method read 25,222 distinct ads of 25,227 Paris apartments. The coverage row says when ads past
the first 10,000 came in price order. SeLoger has no oldest first order of its own: this Actor reads the newest first pages from the
last one back for searches of up to 10,000 ads.

#### Listing details (add-on)

With **Listing details** on, each ad row carries `listingDetails`, read from the ad's record: the whole description, GPS position
(of the address when the agency publishes it, 12 percent of ads, else the centre of the district SeLoger shows), DPE and GES with
figures and the energy bill estimate, co-ownership lots, charges and procedures, the price breakdown with fees, deposit and notary
estimate, features, schools, the area's price per m2, floor plans and virtual tours. Billed as Listing details per row; an ad taken
offline meanwhile is a free row.

#### Agency profiles (add-on) and agency rows

An agency row, and with **Agency profiles** on the `agencyProfile` of each ad row, carries the agency's public page: e-mail and
phones, opening hours, rating and every review SeLoger shows (up to 100), listing counts, description, logo, website, address and
position, and its legal record (legal name and form, SIREN and SIRET, RCS town, capital, professional card, guarantee fund, head
office). Billed once per agency per run, with the first row that carries it.

#### Monitor: new ads, changes and removals

Give the run a **Monitor name** and schedule it. Each run reads every ad updated since its last complete run (less 6 hours of
margin; a first run reads the last 24 hours) and delivers only the ads it never delivered before. With **Track changes and
removals**, an ad it delivered before comes back as a change row when its price changed (or another field you watch: surface,
rooms, bedrooms, energy class, floor, description, photos), with the previous price, the change in euros and percent and the price
history; an ad SeLoger no longer serves comes as a `removed` row and one that comes back as `reappeared`. Change and removed rows
are billed as Listing; with **Also deliver unchanged ads** the others come free. Every results page a monitor run reads is billed.
One monitor name belongs to one set of settings; its memory never forgets an ad, so an ad is never billed twice by one monitor.

#### Personal data

Agencies' data (name, phones, e-mail, address, SIRET) is business data and always delivered. A private seller's shown name and
phone numbers, an agent's own name on an agency's ad and an agency's team members are delivered only when you turn on **Include
personal data** (`includePersonalData`); with it off those fields are empty. Titles, descriptions, key facts, agency
descriptions, reviews and every other text are delivered exactly as SeLoger serves them, with the switch on or off: a phone
number, e-mail address or name that a seller or an agent wrote into a text stays in it. You are responsible for a lawful use of
personal data, GDPR included.

### What this Actor does NOT do

- **No auctions and no senior residences.** SeLoger's search answers no ad for its auction and senior residence values (tested on
  three searches each, 2026-10-18).
- **No street address SeLoger does not publish.** Most agencies hide it; the record then gives the district's centre.
- **No other portals and no public registers.** Only SeLoger's own sites (seloger.com, Belles Demeures, SeLoger Neuf, SeLoger
  Bureaux & Commerces, SeLoger Construire); no PAP, Leboncoin or Logic-Immo, no DVF sales or ADEME energy records.
- **No search radius around a town.** SeLoger searches by place; give several places instead.
- **No login and no account data**: saved searches, alerts and messages are never read.
- One request at a time: a large search takes about 2 minutes per 1,000 ads (500 Lyon apartments in 50 to 58 seconds, measured),
  so the default run timeout of one hour reads about 30,000 ads; raise the timeout in the run options for more. `maxItems`
  defaults to 100.
- **No search links of SeLoger's sister sites.** Search links of seloger-bureaux-commerces.com and the other sister sites are
  refused; their ads come from seloger.com searches of offices, retail and warehouses, and their ad links are accepted.

### API examples

Run it and get the rows in one call (replace `YOUR_TOKEN`):

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~seloger-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"places": ["Lyon"], "propertyTypes": ["apartment"], "maxPrice": 300000, "minRooms": 3, "maxItems": 200}'
```

Node.js:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation_craft/seloger-scraper').call({ places: ['Paris 11e', 'Paris 12e'], transaction: 'rent', maxItems: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((x) => x.type === 'listing'));
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation_craft/seloger-scraper").call(run_input={"agencyDirectory": ["Bordeaux"], "maxItems": 50})
agencies = [x for x in client.dataset(run["defaultDatasetId"]).iterate_items() if x["type"] == "agency"]
```

### FAQ

#### How can I scrape SeLoger listings?

Type a place or paste a SeLoger search link, set a maximum, and start the run: no code, no login and no proxy setup. The rows come
out as JSON, CSV or Excel, or through the Apify API.

#### Is there a SeLoger API for property listings?

SeLoger offers no public API for its listings. This Actor works as one: call it through the Apify API with places, filters or
search links and read the rows back as JSON.

#### How many listings can I export from one SeLoger search?

All of them, up to your `maxItems` (100 by default) and the run's timeout (one hour reads about 30,000 ads). SeLoger serves 10,000
ads of one search in one order; this Actor goes on in price windows, so a search is read to its end, and its coverage row says how
many ads SeLoger holds and how many were delivered.

#### Can I get the agency's phone number and legal details?

Yes. Every professional's ad row carries the agency's name, phones, address, SIRET and RCS; agency rows and the Agency profiles
add-on add the e-mail, opening hours, reviews and the full legal record. A private seller's name and phone are delivered only with
**Include personal data** on.

#### Is it legal to scrape SeLoger?

This Actor reads only what SeLoger shows any visitor, without logging in or solving any captcha. SeLoger's terms reserve its
database and forbid reusing it, and SeLoger has taken sites that reused its listings to court, so you are responsible for a lawful
use: non substantial parts of it, no repeated and systematic extraction beyond a normal use, and the GDPR for any personal data.

#### Why does this Actor run with limited permissions?

It needs nothing more: it writes only to its own run's dataset and key-value store, a monitor keeps its memory in a named key-value
store it creates itself, and it reads only the datasets you pick in **Datasets of ads to leave out**. Limited permissions keep your
other Apify data out of its reach.

### Changelog

- 0.1 (2026-10-18): first release: searches by place and filters, search links, ad links, agency pages and the agency directory;
  every search read to its end; oldest first; monitor with change tracking, removals and reappearances; Listing details and Agency
  profiles add-ons; private persons' data behind the personal data switch.

### More data tools by Automation Craft

- [Leboncoin Scraper: Ads, Prices, Real Estate & Cars](https://apify.com/automation_craft/leboncoin-scraper)
- [Kleinanzeigen Scraper & API: Ads, Prices, Places](https://apify.com/automation_craft/kleinanzeigen-scraper)
- [Mobile.de Scraper: Cars, Prices, Dealers & Ratings](https://apify.com/automation_craft/mobile-de-scraper)
- [AutoScout24 Scraper: EU Car Listings & Prices](https://apify.com/automation_craft/autoscout24-scraper)
- [Facebook Marketplace Scraper with Sold Tracker](https://apify.com/automation_craft/facebook-marketplace-scraper)
- [Craigslist Scraper: Listings, Prices & Alerts](https://apify.com/automation_craft/craigslist-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/seloger-scraper/changelog.md

# Actor input Schema

## `places` (type: `array`):

Towns, arrondissements, neighbourhoods, departments, regions or postal codes, as you would type them on SeLoger: Paris, Paris 18e, Lyon 3e, Montmartre, Gironde, Bretagne, 75018, 33 (a department number), Saint-Denis (93). A name must match exactly one SeLoger place (add the department or postal code when several share it); a name that matches none or several gives a free row with the candidates. SeLoger place codes (AD08FR31096) are accepted too.

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

Ads for sale or for rent. Default buy.

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

Default apartment and house.

## `projectTypes` (type: `array`):

For sale: resale, new_build, life_annuity, investment, construction_project. For rent: standard, flatsharing, short_term. Default every kind.

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

The lowest price, in euros (the monthly rent for rentals).

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

The highest price, in euros (the monthly rent for rentals).

## `minPricePerSqm` (type: `integer`):

The lowest price per square metre, checked on every row (SeLoger's own figure, else the price divided by the surface). An ad without a price per m2 is left out, free.

## `maxPricePerSqm` (type: `integer`):

The highest price per square metre, checked on every row. An ad without a price per m2 is left out, free.

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

The smallest living surface in square metres.

## `maxSurface` (type: `integer`):

The largest living surface in square metres.

## `minPlotSurface` (type: `integer`):

The smallest plot of land in square metres.

## `maxPlotSurface` (type: `integer`):

The largest plot of land in square metres.

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

The fewest rooms.

## `maxRooms` (type: `integer`):

The most rooms.

## `minBedrooms` (type: `integer`):

The fewest bedrooms.

## `maxBedrooms` (type: `integer`):

The most bedrooms.

## `minYearBuilt` (type: `integer`):

The earliest year of construction.

## `maxYearBuilt` (type: `integer`):

The latest year of construction.

## `energyClasses` (type: `array`):

Only ads with one of these energy performance classes (DPE).

## `features` (type: `array`):

Only ads with every one of these features.

## `heatingTypes` (type: `array`):

Only ads with one of these heating types.

## `floors` (type: `array`):

Which floors to include (SeLoger's own floor choice).

## `furnished` (type: `string`):

Rentals only.

## `availableBefore` (type: `string`):

Rentals available on or before this date (YYYY-MM-DD).

## `sellerType` (type: `string`):

Private sellers or professionals only.

## `needsRenovation` (type: `boolean`):

Only ads SeLoger marks as needing renovation.

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

Words SeLoger looks for in the whole ad text (piscine, terrasse, vue mer). Up to 10, each up to 60 characters.

## `postedWithinDays` (type: `integer`):

Only ads first published in the last N days. The search is read newest first and stops at the first page older than that.

## `postedWithinHours` (type: `integer`):

Only ads first published in the last N hours (instead of days). The search is read newest first and stops at the first page older than that. Not with a monitor, which reads every ad updated since its last run.

## `minDaysOnMarket` (type: `integer`):

Only ads first published at least N days ago: the listings that have not sold or let yet. Each row also carries daysOnMarket.

## `withPhoneOnly` (type: `boolean`):

Only ads whose card shows a phone number.

## `withPhotosOnly` (type: `boolean`):

Only ads that show at least one photo.

## `excludeAdIds` (type: `array`):

SeLoger ad ids or links you already have; they are skipped, free. Up to 10,000.

## `excludeDatasetIds` (type: `array`):

Ids of your Apify datasets (an earlier run of this Actor, or any dataset whose rows carry a SeLoger ad id or link in "id" or "url"): their ads are skipped, free. Up to 10 datasets and 200,000 ads; a dataset that cannot be read stops the run before any paid work. Only the datasets picked here are readable to the run (limited permissions).

## `sort` (type: `string`):

The order of a search. Newest first sorts on the ad's last update; oldest first reads a search of up to 10,000 ads from its last page back (SeLoger has no such order of its own), a larger one in price order. Past the first 10,000 ads of one order the search goes on in price order. A pasted link keeps its own order unless you set one here. Default newest first.

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

The most paid rows the run delivers (ad rows, price change and removed rows, agency rows together). Default 100.

## `maxItemsPerSearch` (type: `integer`):

The most rows one search, link, agency or directory town delivers.

## `maxPagesPerSearch` (type: `integer`):

The most results pages (up to 100 ads each) one search reads.

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

Search links copied from seloger.com: a filtered search (https://www.seloger.com/classified-search?...) or a search page (https://www.seloger.com/recherche/achat/appartement/...). Every page is read. A link that carries a parameter SeLoger's search does not know, or a page above 1, is refused with a free row.

## `adUrls` (type: `array`):

Ads to read directly: seloger.com ad links, Belles Demeures, SeLoger Neuf, SeLoger Bureaux & Commerces and SeLoger Construire ad links, 12 character SeLoger ids or the older numeric ids. An ad SeLoger no longer has is a free row. Up to 5,000.

## `agencyUrls` (type: `array`):

Agency pages on SeLoger (https://www.seloger.com/professionnels-immobilier/<id>) or their ids. Each gives one agency row and, with the switch below, the agency's ads.

## `includeAgencyListings` (type: `boolean`):

For each agency link, also deliver the ads its page lists (its default list: for sale, else for rent). Default on.

## `agencyDirectory` (type: `array`):

Towns whose real estate agencies you want (Bordeaux, Lyon) or SeLoger directory links (https://www.seloger.com/annuaire/bordeaux-33000/). Every agency of the town's directory gives one agency row.

## `agencyNameContains` (type: `string`):

Agency links and the directory: only agencies whose name contains this text (any case, accents ignored).

## `agencyNetwork` (type: `string`):

Agency links and the directory: only agencies of this network or franchise (Century 21, Orpi, Laforêt), as SeLoger names it.

## `agenciesWithPhoneOnly` (type: `boolean`):

Agency links and the directory: only agencies whose page shows a phone number.

## `agenciesWithEmailOnly` (type: `boolean`):

Agency links and the directory: only agencies whose page shows an e-mail address.

## `includeDetails` (type: `boolean`):

Read each delivered ad's full record: the whole description, GPS position (of the address when published, else the centre of the area SeLoger shows), DPE and GES with figures and the energy bill estimate, co-ownership lots, charges and procedures, the price breakdown with fees, deposit and notary estimate, features, schools, the area's price per m2, floor plans and virtual tours. Billed as Listing details per row.

## `includeAgencyProfiles` (type: `boolean`):

Add the agency's public profile to its ad rows: contact e-mail and phone, opening hours, rating, reviews, listing counts. Read and billed once per agency per run, with its first row.

## `includePersonalData` (type: `boolean`):

Off by default. On: a private seller's shown name and phone numbers (privateSellerName, privateSellerPhones), an agent's own name on agency ads (contactName) and an agency's team members (teamMembers) are delivered as SeLoger shows them logged out. Off: those fields are empty. Titles, descriptions, reviews and every other text are delivered exactly as SeLoger serves them, on or off. You are responsible for using personal data lawfully (GDPR included).

## `monitorName` (type: `string`):

A short name of your choice (letters, digits, spaces and . \_ , - : # ( ), up to 60 characters). One name belongs to one set of settings.

## `trackChanges` (type: `boolean`):

With a monitor: an ad it delivered before whose price (or another watched field, below) changed is delivered again with what changed, an ad SeLoger no longer serves is reported as removed and a removed ad that comes back as reappeared (all billed as Listing). Removals need every id of the searches listed each run, every results page billed.

## `changeFields` (type: `array`):

With trackChanges: which changes of a known ad deliver it again (billed as Listing). A price change row carries the previous price, the change in euros and percent and the price history. Default price only.

## `includeUnchanged` (type: `boolean`):

With trackChanges: known ads met again without a watched change are delivered too, free, marked unchanged (they never count toward the maximum).

## `webhookUrl` (type: `string`):

An https address the run posts its new rows to (JSON, up to 100 rows a call, at most 1,000 a run, with a plain text summary in the field "text" that Slack and Mattermost incoming webhooks show).

## `webhookSecret` (type: `string`):

Optional: each call then carries an x-signature-sha256 header, the HMAC SHA-256 of the body with this secret (16 to 200 letters, digits and - \_ . ~, with at least one letter and one digit).

## `telegramBotToken` (type: `string`):

Your own bot's token from BotFather; the run sends one message per new row (at most 30).

## `telegramChatId` (type: `string`):

The chat id (a number) or channel name (@name) your bot posts to.

## `failIfIncomplete` (type: `boolean`):

Mark the run failed when a search, link or agency could not be read to its end for a reason other than your own limits. The rows delivered stay.

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

Apify residential proxies are used by default and included in the price (Germany unless you choose a country). SeLoger refuses datacenter addresses, so other Apify groups are refused; your own proxy links (http://user:password@host:port, the password 12 characters or more with letters and digits, no space) can be given instead.

## Actor input object example

```json
{
  "places": [
    "Paris 18e"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `items` (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 = {
    "places": [
        "Paris 18e"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/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 = {
    "places": ["Paris 18e"],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/seloger-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "places": [
    "Paris 18e"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call automation_craft/seloger-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/seloger-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ayLu4eSoD1eEyxADo/builds/2bsGzmof632ORFVLg/openapi.json
