# New French Building Permits Finder (SITADEL) (`fit_melon/new-french-building-permits-finder-sitadel`) Actor

Find newly authorized French building permits (permis de construire, DP, PA, PD) from the official SITADEL database. Filter by department, commune, date, dwellings. Get project, address and company applicant SIREN/SIRET for BTP lead generation.

- **URL**: https://apify.com/fit\_melon/new-french-building-permits-finder-sitadel.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Lead generation, Real estate
- **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

## New French Building Permits Finder (SITADEL)

Find **newly authorized French building permits** — *permis de construire (PC), déclarations préalables (DP), permis d'aménager (PA) and permis de démolir (PD)* — straight from **SITADEL**, the official database of the French Ministry of Ecological Transition (SDES). Filter by department, INSEE commune, authorization date, number of dwellings, and keep only permits filed by **companies (personne morale)** to get their **SIREN / SIRET / APE code** — instant B2B leads for the French construction market (BTP).

Every new permit is a buying signal: someone is about to build, extend, demolish or develop land. This actor turns the raw open data — millions of rows, cryptic column names, monthly file rotations — into clean, structured JSON you can plug into Make, n8n, Zapier, a CRM or a spreadsheet.

**This actor is free.** You only pay your Apify platform usage.

### What you get for each permit

- Permit number, document type (PC / DP / PA / PD) and permit list (housing, non-residential, development, demolition)
- **Real authorization date**, filing date, work-start and completion dates, plus a derived `projectState` (`authorized` / `work_started` / `completed`)
- Work-site location: address, postal code, city, INSEE commune code, department, region, cadastral parcels, land area
- **Applicant**: company name, **SIREN, SIRET, APE/NAF code**, postal code and city (when the applicant is a legal entity)
- Project details: new construction vs. work on existing, architect involved, dwellings created (total / individual / collective / social housing), floor areas created (housing and non-residential), pool/extension flags

### Input

| Field | Type | Description |
|---|---|---|
| `permitTypes` | array | Lists to search: `housing`, `nonResidential`, `development`, `demolition`. Default `["housing"]` |
| `departments` | array | Department codes (`59`, `75`, `2A`, `971`…). Empty = all France |
| `communes` | array | Optional INSEE commune codes (e.g. `59350` for Lille) |
| `monthsBack` | integer | Rolling window in months (default `3`) |
| `authorizedAfter` / `authorizedBefore` | string | Explicit ISO date bounds on the authorization date |
| `minDwellings` | integer | Housing list only: minimum dwellings created (spot real-estate developments) |
| `companiesOnly` | boolean | Keep only permits filed by a company — B2B lead mode |
| `maxResults` | integer | Cap on pushed items (default `200`) |

### Output example

```json
{
  "status": "found",
  "permitType": "housing",
  "documentType": "PC",
  "permitNumber": "0594142600004",
  "projectState": "authorized",
  "dateAuthorized": "2026-05-29",
  "dateFiled": "2026-05-29",
  "location": {
    "address": "ROUTE DE LALLAING - LOT 20",
    "postalCode": "59182",
    "city": "MONTIGNY-EN-OSTREVENT",
    "inseeCommuneCode": "59414",
    "departmentCode": "59",
    "departmentName": "Nord",
    "regionName": "Hauts-de-France",
    "cadastre": ["AA 279"]
  },
  "applicant": {
    "isCompany": false,
    "name": null,
    "siren": null,
    "siret": null,
    "apeCode": null,
    "postalCode": "59167",
    "city": "LALLAING"
  },
  "project": {
    "nature": "new_construction",
    "usesArchitect": false,
    "landAreaM2": 414,
    "dwellingsCreated": 1,
    "floorAreaHousingCreatedM2": 93
  },
  "source": {
    "name": "SITADEL (SDES / Ministère de la Transition écologique)",
    "millesime": "2026-06",
    "api": "DiDo diffusion API"
  }
}
````

Items always carry an explicit `status`: `found`, `not_found` (no permit matched your filters) or `error`.

### Use cases

- **BTP lead generation**: new permits in your area = prospects for builders, roofers, electricians, kitchen fitters, landscapers, fencing, solar installers. Run weekly with `companiesOnly` off for local mailing, or on to target developers.
- **Real-estate development watch**: `minDwellings: 10` reveals upcoming residential programmes — feed developers' SIREN into a company enrichment step to reach decision makers.
- **Market intelligence**: track construction dynamics by commune or department, month after month.
- **Supplier prospecting**: non-residential permits (warehouses, offices, industry) signal companies investing in premises.

### Data source, freshness & fair use

Data comes from the official **SITADEL open database** published monthly by the SDES (statistical service of the French Ministry of Ecological Transition) under the Etalab open licence, queried through the public DiDo API — no scraping, no API key, no proxies. Authorizations are listed since 2013; the current month's millésime is used automatically. Note: permits appear with an administrative delay of one to a few months after the authorization date, and applicant identity is only published for legal entities (individuals are anonymized, per French regulation). Please keep politeness delays in place and avoid hammering the source.

### More actors by this developer

This actor is part of a French business data suite — combine it into a full pipeline:

- **[French Company Data Enricher (SIREN)](https://apify.com/fit_melon/french-company-data-enricher-siren-dirigeants-sirene)** — turn each applicant SIREN into full company data (directors, address, activity).
- **[French Insolvency & Solvency Checker (BODACC)](https://apify.com/fit_melon/french-insolvency-checker-bodacc)** — check the solvency of developers before working with them.
- **[French RGE Certified Contractors Finder (ADEME)](https://apify.com/fit_melon/french-rge-certified-contractors-finder-ademe)** — find certified contractors near the permit's commune.
- **[New French Companies Finder (SIRENE)](https://apify.com/fit_melon/new-french-companies-finder-sirene)** — spot newly created construction companies.

Browse all actors: [apify.com/fit\_melon](https://apify.com/fit_melon)

# Actor input Schema

## `permitTypes` (type: `array`):

Which SITADEL lists to search: `housing` (building permits & prior declarations creating dwellings), `nonResidential` (offices, shops, warehouses, industry…), `development` (permis d'aménager), `demolition` (permis de démolir).

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

French department codes to filter on (e.g. 59, 75, 2A, 971). Leave empty to search all of France.

## `communes` (type: `array`):

Optional INSEE commune codes (e.g. 59350 for Lille). Narrower than departments.

## `monthsBack` (type: `integer`):

Rolling window: only permits authorized in the last N months. Ignored if 'Authorized after' is set.

## `authorizedAfter` (type: `string`):

Only permits with a real authorization date on or after this ISO date. Overrides 'Months back'.

## `authorizedBefore` (type: `string`):

Optional upper bound on the real authorization date (ISO format).

## `minDwellings` (type: `integer`):

Housing list only: keep permits creating at least this many dwellings (spot real estate developments).

## `companiesOnly` (type: `boolean`):

Keep only permits filed by a legal entity (personne morale) — the output then includes the applicant's SIREN/SIRET, name and APE code, ready for enrichment.

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

Maximum number of permit items pushed to the dataset (across all selected types).

## Actor input object example

```json
{
  "permitTypes": [
    "housing"
  ],
  "departments": [
    "59"
  ],
  "monthsBack": 3,
  "companiesOnly": false,
  "maxResults": 200
}
```

# 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 = {
    "permitTypes": [
        "housing"
    ],
    "departments": [
        "59"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/new-french-building-permits-finder-sitadel").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 = {
    "permitTypes": ["housing"],
    "departments": ["59"],
}

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/new-french-building-permits-finder-sitadel").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 '{
  "permitTypes": [
    "housing"
  ],
  "departments": [
    "59"
  ]
}' |
apify call fit_melon/new-french-building-permits-finder-sitadel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/new-french-building-permits-finder-sitadel",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New French Building Permits Finder (SITADEL)",
        "description": "Find newly authorized French building permits (permis de construire, DP, PA, PD) from the official SITADEL database. Filter by department, commune, date, dwellings. Get project, address and company applicant SIREN/SIRET for BTP lead generation.",
        "version": "0.0",
        "x-build-id": "NeW5eTVgQQHJ7996I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~new-french-building-permits-finder-sitadel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-new-french-building-permits-finder-sitadel",
                "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/fit_melon~new-french-building-permits-finder-sitadel/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-new-french-building-permits-finder-sitadel",
                "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/fit_melon~new-french-building-permits-finder-sitadel/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-new-french-building-permits-finder-sitadel",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "permitTypes": {
                        "title": "Permit types",
                        "type": "array",
                        "description": "Which SITADEL lists to search: `housing` (building permits & prior declarations creating dwellings), `nonResidential` (offices, shops, warehouses, industry…), `development` (permis d'aménager), `demolition` (permis de démolir).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "housing",
                                "nonResidential",
                                "development",
                                "demolition"
                            ],
                            "enumTitles": [
                                "Housing (PC/DP logements)",
                                "Non-residential (PC/DP locaux)",
                                "Development (PA)",
                                "Demolition (PD)"
                            ]
                        }
                    },
                    "departments": {
                        "title": "Department codes",
                        "type": "array",
                        "description": "French department codes to filter on (e.g. 59, 75, 2A, 971). Leave empty to search all of France.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "communes": {
                        "title": "INSEE commune codes",
                        "type": "array",
                        "description": "Optional INSEE commune codes (e.g. 59350 for Lille). Narrower than departments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "monthsBack": {
                        "title": "Months back",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Rolling window: only permits authorized in the last N months. Ignored if 'Authorized after' is set.",
                        "default": 3
                    },
                    "authorizedAfter": {
                        "title": "Authorized after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only permits with a real authorization date on or after this ISO date. Overrides 'Months back'."
                    },
                    "authorizedBefore": {
                        "title": "Authorized before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional upper bound on the real authorization date (ISO format)."
                    },
                    "minDwellings": {
                        "title": "Minimum dwellings created",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Housing list only: keep permits creating at least this many dwellings (spot real estate developments)."
                    },
                    "companiesOnly": {
                        "title": "Companies only (B2B leads)",
                        "type": "boolean",
                        "description": "Keep only permits filed by a legal entity (personne morale) — the output then includes the applicant's SIREN/SIRET, name and APE code, ready for enrichment.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of permit items pushed to the dataset (across all selected types).",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
