# French Real Estate Pige CRM Export (`davidbenittah/french-real-estate-pige-crm-export`) Actor

French real estate pige CRM export: aggregate LBC, SeLoger, PAP and Bien'ici listings, deduplicate properties, output first-seen leads.

- **URL**: https://apify.com/davidbenittah/french-real-estate-pige-crm-export.md
- **Developed by:** [David](https://apify.com/davidbenittah) (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

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## French Real Estate Pige CRM Export

**French real estate pige CRM export** aggregates French property listings from Leboncoin, SeLoger, PAP and Bien'ici, deduplicates the same property across portals, and outputs a CRM-ready lead feed with first-seen dates. It is built for agents immobiliers, chasseurs, marchands de biens, and acquisition teams who do a daily pige manually.

### Features

- **Multi-source French pige**: run one search across PAP, Bien'ici, Leboncoin and SeLoger through the upstream French real-estate scraper.
- **Deduplication across portals**: the same property listed on several sites becomes one CRM lead with all source URLs preserved.
- **CRM-ready export**: stable `crmLeadId`, `firstSeenAt`, price, surface, rooms, €/m², DPE/GES, owner-vs-agency signal, source portals and URLs.
- **First-seen tracking**: scheduled runs remember previous listings and flag `isNewSinceLastRun` so your CRM only imports fresh leads.
- **Safe input caps**: maximum 5 sources, 20 cities, 50 postal codes, and 200 results per source to prevent runaway runs.
- **Runs with defaults**: PAP + Bien'ici in Lyon works without a residential proxy; enable Leboncoin/SeLoger when you provide a French residential proxy through the upstream actor.

### Use cases

- **Agents immobiliers**: daily pige by city or department without copy-pasting four portals.
- **Chasseurs d'appart / marchands**: fresh owner listings and under-the-radar stock pushed into a CRM.
- **Market monitors**: track available stock, prices, and €/m² by zone every morning.
- **Lead enrichment workflows**: send deduplicated property leads to Google Sheets, Airtable, HubSpot or a webhook via Apify integrations.

### Input / Output

Input example:

```json
{
  "sources": ["pap", "bienici", "leboncoin", "seloger"],
  "transaction": "buy",
  "cities": ["lyon"],
  "propertyTypes": ["appartement"],
  "priceMax": 350000,
  "maxResultsPerSource": 20,
  "publishedWithinHours": 72
}
````

Output example — one dataset item per deduplicated CRM lead:

```json
{
  "crmLeadId": "fr-immo-7e2e4b...",
  "monitorKey": "lyon-buy-apartments",
  "firstSeenAt": "2026-07-06T06:00:00.000Z",
  "isNewSinceLastRun": true,
  "title": "Studio neuf Lyon 7",
  "city": "Lyon",
  "postalCode": "69007",
  "priceEur": 168000,
  "surfaceM2": 28,
  "rooms": 1,
  "pricePerM2": 6000,
  "sourcePortals": ["pap"],
  "sourceUrls": ["https://www.pap.fr/annonces/..."],
  "ownerType": "owner"
}
```

### Pricing

Pay per event: you are charged per CRM-ready dataset item returned by this actor, plus the upstream scraper cost for the portals scanned. Start with `maxResultsPerSource: 20` to validate your zone before scaling. The source scraper currently advertises $5 / 1,000 listings; this wrapper is calibrated for the same low-volume daily pige use case.

### FAQ

**Does it scrape Leboncoin and SeLoger directly?**
No. It calls the existing Apify actor `dltik/pige-immo-fr-scraper`, which already handles the French portal-specific scraping and proxy requirements. This actor adds CRM export, first-seen tracking, stricter input caps, and a stable deduplicated lead schema.

**Why do PAP and Bien'ici run by default?**
They are the safer default because the upstream actor says they work without residential proxy. Leboncoin and SeLoger are available, but require French residential proxy through the upstream actor.

**How does deduplication work?**
Listings are grouped by postal code, city, price, surface, rooms, property type and title fingerprint. The most complete record is kept, while all source portals and URLs are preserved.

**Can I schedule it daily?**
Yes. Use one scheduled task per zone. The actor stores a baseline per monitor and flags `isNewSinceLastRun` on later runs.

# Actor input Schema

## `sources` (type: `array`):

Portals to include. PAP and Bien'ici run without residential proxy; Leboncoin and SeLoger require French residential proxy in the upstream scraper.

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

buy = vente, rent = location.

## `cities` (type: `array`):

City names such as Lyon, Paris, Marseille. Hard maximum: 20.

## `postalCodes` (type: `array`):

French 5-digit postal codes. Hard maximum: 50.

## `departments` (type: `array`):

French department codes such as 75, 69, 13. Hard maximum: 20.

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

Examples: appartement, maison, terrain, parking, local, loft, chateau.

## `priceMin` (type: `integer`):

Minimum listing price in euros.

## `priceMax` (type: `integer`):

Maximum listing price in euros.

## `surfaceMin` (type: `integer`):

Minimum living surface in square meters.

## `surfaceMax` (type: `integer`):

Maximum living surface in square meters.

## `roomsMin` (type: `integer`):

Minimum number of rooms.

## `roomsMax` (type: `integer`):

Maximum number of rooms.

## `onlyOwner` (type: `boolean`):

Filter to particulier / owner listings when the upstream portal supports it.

## `publishedWithinHours` (type: `integer`):

Keep only listings published in the last N hours when the upstream source exposes publication time. Default 72 for daily pige workflows.

## `maxResultsPerSource` (type: `integer`):

Safety cap per portal. Hard maximum: 200 per source.

## `includeBaselineInOutput` (type: `boolean`):

First run saves a baseline and can output all matching listings. Later runs flag first-seen/new items for CRM import.

## `monitorId` (type: `string`):

Optional stable ID for this zone/search. Change it to reset first-seen tracking.

## `customProxyUrl` (type: `string`):

Optional upstream proxy URL for Leboncoin/SeLoger through the source scraper. Secret field.

## `proxyConfig` (type: `object`):

For Leboncoin/SeLoger, use Apify RESIDENTIAL with country FR. Defaults are conservative for PAP/Bien'ici.

## Actor input object example

```json
{
  "sources": [
    "pap",
    "bienici",
    "leboncoin",
    "seloger"
  ],
  "transaction": "buy",
  "cities": [
    "lyon"
  ],
  "postalCodes": [],
  "departments": [],
  "propertyTypes": [
    "appartement"
  ],
  "onlyOwner": false,
  "publishedWithinHours": 72,
  "maxResultsPerSource": 20,
  "includeBaselineInOutput": true,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "sources": [
        "pap",
        "bienici",
        "leboncoin",
        "seloger"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("davidbenittah/french-real-estate-pige-crm-export").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 = { "sources": [
        "pap",
        "bienici",
        "leboncoin",
        "seloger",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("davidbenittah/french-real-estate-pige-crm-export").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 '{
  "sources": [
    "pap",
    "bienici",
    "leboncoin",
    "seloger"
  ]
}' |
apify call davidbenittah/french-real-estate-pige-crm-export --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "French Real Estate Pige CRM Export",
        "description": "French real estate pige CRM export: aggregate LBC, SeLoger, PAP and Bien'ici listings, deduplicate properties, output first-seen leads.",
        "version": "1.0",
        "x-build-id": "0FCw6Sdknw5MBwLCA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/davidbenittah~french-real-estate-pige-crm-export/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-davidbenittah-french-real-estate-pige-crm-export",
                "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/davidbenittah~french-real-estate-pige-crm-export/runs": {
            "post": {
                "operationId": "runs-sync-davidbenittah-french-real-estate-pige-crm-export",
                "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/davidbenittah~french-real-estate-pige-crm-export/run-sync": {
            "post": {
                "operationId": "run-sync-davidbenittah-french-real-estate-pige-crm-export",
                "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": [
                    "sources",
                    "transaction"
                ],
                "properties": {
                    "sources": {
                        "title": "Portals to aggregate",
                        "type": "array",
                        "description": "Portals to include. PAP and Bien'ici run without residential proxy; Leboncoin and SeLoger require French residential proxy in the upstream scraper.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "pap",
                            "bienici"
                        ]
                    },
                    "transaction": {
                        "title": "Transaction",
                        "enum": [
                            "buy",
                            "rent"
                        ],
                        "type": "string",
                        "description": "buy = vente, rent = location.",
                        "default": "buy"
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names such as Lyon, Paris, Marseille. Hard maximum: 20.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "lyon"
                        ]
                    },
                    "postalCodes": {
                        "title": "Postal codes",
                        "type": "array",
                        "description": "French 5-digit postal codes. Hard maximum: 50.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "departments": {
                        "title": "Departments",
                        "type": "array",
                        "description": "French department codes such as 75, 69, 13. Hard maximum: 20.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Examples: appartement, maison, terrain, parking, local, loft, chateau.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "appartement"
                        ]
                    },
                    "priceMin": {
                        "title": "Min price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price in euros."
                    },
                    "priceMax": {
                        "title": "Max price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price in euros."
                    },
                    "surfaceMin": {
                        "title": "Min surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living surface in square meters."
                    },
                    "surfaceMax": {
                        "title": "Max surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living surface in square meters."
                    },
                    "roomsMin": {
                        "title": "Min rooms",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of rooms."
                    },
                    "roomsMax": {
                        "title": "Max rooms",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of rooms."
                    },
                    "onlyOwner": {
                        "title": "Owner-only listings",
                        "type": "boolean",
                        "description": "Filter to particulier / owner listings when the upstream portal supports it.",
                        "default": false
                    },
                    "publishedWithinHours": {
                        "title": "Fresh listings window",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "Keep only listings published in the last N hours when the upstream source exposes publication time. Default 72 for daily pige workflows.",
                        "default": 72
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap per portal. Hard maximum: 200 per source.",
                        "default": 20
                    },
                    "includeBaselineInOutput": {
                        "title": "Output baseline on first run",
                        "type": "boolean",
                        "description": "First run saves a baseline and can output all matching listings. Later runs flag first-seen/new items for CRM import.",
                        "default": true
                    },
                    "monitorId": {
                        "title": "Custom monitor ID",
                        "type": "string",
                        "description": "Optional stable ID for this zone/search. Change it to reset first-seen tracking."
                    },
                    "customProxyUrl": {
                        "title": "Custom FR residential proxy URL",
                        "type": "string",
                        "description": "Optional upstream proxy URL for Leboncoin/SeLoger through the source scraper. Secret field."
                    },
                    "proxyConfig": {
                        "title": "Proxy config for upstream scraper",
                        "type": "object",
                        "description": "For Leboncoin/SeLoger, use Apify RESIDENTIAL with country FR. Defaults are conservative for PAP/Bien'ici.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
