# French PLU & Urban Zoning Lookup (Géoportail de l'Urbanisme) (`dalbian/french-plu-urbanisme-lookup`) Actor

Look up French urban planning rules for any address, parcel, coordinate or commune: PLU/PLUi zoning, zone labels, building prescriptions, public easements (SUP) and direct links to the official written règlement.

- **URL**: https://apify.com/dalbian/french-plu-urbanisme-lookup.md
- **Developed by:** [Benjamin Jerez](https://apify.com/dalbian) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 location resolveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## French PLU & Urban Zoning Lookup (Géoportail de l'Urbanisme)

Turn a French address, cadastral parcel or commune code into the urban-planning rules that actually apply to it: the **PLU** zone, its full label, the graphic prescriptions that constrain building, the public easements (**servitudes d'utilité publique**), and a direct link to the written *règlement* — often down to the exact page.

Checking one plot by hand on the Géoportail de l'Urbanisme takes several minutes of panning, clicking and PDF hunting. This Actor does it in about a second per location, for a list of any size, and returns a flat table you can drop into a spreadsheet, a CRM or a valuation model.

### Who this is for

- **Diagnostiqueurs and notaires** preparing a sale file who need the zone and the easements on record.
- **Developers, land hunters and architects** screening plots for feasibility before spending on a survey.
- **Utility, telecom and civil-engineering firms** checking protected perimeters along a route.
- **Estate agencies and proptech products** enriching a portfolio with planning context.
- **Researchers and analysts** mapping the zoning of a whole commune in one call.

### What you get for each location

| Field | What it tells you |
| --- | --- |
| `zoneCode` / `zoneLabel` | The PLU zone (`UA`, `AUc`, `N`, `A`…) and its official wording |
| `zoneFamily` | U, AU, A or N — urban, to-be-urbanised, agricultural, natural |
| `regulationFileName` / `regulationUrl` | The written règlement, sometimes anchored to the exact page |
| `documentType` / `documentId` | PLU, PLUi, POS, carte communale or **PSMV** for protected sectors, with its approval date |
| `prescriptions` | Protected hedges and trees, alignments, reserved emplacements, protected frontage |
| `easements` | Historic-monument perimeters, gas and power lines, airport noise, water catchment |
| `parcelId` / `parcelAreaSqm` | Cadastral identity and surface, when you query by parcel |
| `gpuViewerUrl` | A deep link that opens the official map at that exact point |

### Four ways to ask

**Addresses** — free text, geocoded against the official BAN address base, with the match score returned so you can spot a weak match:

```
12 rue de la République, 84000 Avignon
```

**Cadastral parcels** — the unit that matters for permits and land deals. Both forms work:

```
84141,AW,1
84141000AW0001
```

**Coordinates** — `longitude,latitude` in WGS84, longitude first, as in GeoJSON:

```
4.8055,43.9493
```

**INSEE commune codes** — returns every zoning polygon of the territory instead of a single point:

```
84141
```

### An honest note on coverage

Not every square metre of France carries a PLU zone, and the Actor says so rather than returning a silent blank. When no polygon covers a point, `zoningStatus` is `no-zone-at-this-point` and `zoningNote` explains the likely reason: a protected sector under a separate **PSMV** plan, public land left outside the zoning, a commune under national rules (**RNU**), or a gap in what the commune has uploaded. Paris's Marais, for example, comes back as a PSMV with zone `US`, while Avignon *intra-muros* comes back with no polygon at all — both are correct answers, and both are worth knowing before you quote a rule.

### Pricing

You pay per location successfully resolved. Failed lookups — an address the BAN cannot match, a parcel that does not exist — are returned with an explanatory `error` and are not charged.

### Data sources and licence

Everything comes from French public-sector open data, queried live so the answer reflects what is in force today:

- **Géoportail de l'Urbanisme** via the IGN APIcarto GPU module — zoning, prescriptions, easements, planning documents
- **IGN APIcarto cadastre module** — parcel outlines and areas
- **Base Adresse Nationale (BAN)** — address geocoding

These are published under the Licence Ouverte / Etalab. The Actor reads no personal data and requires no credentials.

### Frequently asked

**Does it return the full text of the règlement?**
It returns the file name and the link, with the page anchor where the source provides one. The PDFs stay on the commune's or the Géoportail's servers.

**How fresh is the data?**
It is read live from the API on every run. `lastUpdatedOnGpu` tells you when the commune last published, and `documentId` carries the approval date, so you can tell a 2013 plan from a 2026 one at a glance.

**Can I map an entire commune?**
Yes — pass the INSEE code. Avignon returns 142 zones and over 3,000 prescriptions in a single row.

**Does it work in Corsica and the DOM?**
Corsican codes such as `2A004` work. Overseas coverage follows whatever the Géoportail publishes.

# Actor input Schema

## `addresses` (type: `array`):

French postal addresses to look up, one per line. Each address is geocoded with the official BAN address base, then the exact PLU zone at that point is returned. Use this when you have a client file, a prospect list or a portfolio of properties. Example: 12 rue de la République, 84000 Avignon

## `inseeCodes` (type: `array`):

Five-character INSEE codes of whole communes, one per line. Returns every zoning polygon of the commune instead of a single point. Use this to map a whole territory. Corsica codes such as 2A004 are supported. Example: 84129

## `coordinates` (type: `array`):

WGS84 coordinates as 'longitude,latitude', one pair per line. Longitude comes first, as in GeoJSON. Use this when your data is already geocoded and you want to skip the address-matching step. Example: 4.8055,43.9493

## `parcels` (type: `array`):

Cadastral references as 'insee,section,number', one per line. The parcel outline is resolved first, then the zoning that covers it. Use this for building-permit and land-acquisition work, where the parcel — not the street address — is the unit. Example: 84129,AY,368

## `includeZoning` (type: `boolean`):

Return the PLU zone covering each location: its code (UB, AUc, N, A...), full label, zone family and a link to the written règlement. This is the core of the result, so leave it on unless you only need easements.

## `includePrescriptions` (type: `boolean`):

Return graphic prescriptions that constrain building: protected hedges and trees, mandatory alignments, reserved emplacements, protected retail frontage. These are what turn a permissive zone into a difficult plot, so keep this on for feasibility work.

## `includeEasements` (type: `boolean`):

Return servitudes d'utilité publique affecting the location: historic-monument perimeters, gas and power lines, airport and noise zones, water catchment protection. Off by default because it adds one request per location and is not needed for simple zoning checks.

## `includeDocumentInfo` (type: `boolean`):

Return which planning document applies (PLU, PLUi, POS, carte communale or none), when it was approved and where the full file sits on the Géoportail. Useful for checking that a rule you are quoting is still the one in force.

## `maxLocations` (type: `integer`):

Hard stop on how many locations are processed in this run. Set it below your list size for a cheap trial run before committing a full batch.

## Actor input object example

```json
{
  "addresses": [
    "1 place de l'Horloge, 84000 Avignon"
  ],
  "includeZoning": true,
  "includePrescriptions": true,
  "includeEasements": false,
  "includeDocumentInfo": true,
  "maxLocations": 1000
}
```

# Actor output Schema

# 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 = {
    "addresses": [
        "1 place de l'Horloge, 84000 Avignon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dalbian/french-plu-urbanisme-lookup").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 = { "addresses": ["1 place de l'Horloge, 84000 Avignon"] }

# Run the Actor and wait for it to finish
run = client.actor("dalbian/french-plu-urbanisme-lookup").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 '{
  "addresses": [
    "1 place de l'\''Horloge, 84000 Avignon"
  ]
}' |
apify call dalbian/french-plu-urbanisme-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dalbian/french-plu-urbanisme-lookup"
        }
    }
}
```

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/ZmvtNxB3edX5breAg/builds/OY5vLyzeTJPPtKkPI/openapi.json