Rechercher des parcelles cadastrales

L'API Infoparcelle permet de rechercher et d'analyser les parcelles cadastrales françaises avec leurs géométries complètes, superficies, propriétaires et toutes les données associées. Ce guide vous explique comment utiliser l'endpoint de recherche de parcelles.

Vue d'ensemble

L'endpoint /api/v1/parcelles/recherche vous permet de filtrer les parcelles cadastrales selon de nombreux critères : localisation, superficie, type de bâti, DPE, transactions DVF, risques, etc.

Fonctionnalités principales

✅ Recherche multicritère puissante (67 filtres disponibles)
✅ Filtres géographiques (GPS, code postal, département, commune, IRIS)
✅ Filtres de bâti (type, surface, étages, année de construction)
✅ Filtres énergétiques (DPE, consommations)
✅ Filtres de transactions (DVF, prix, dates)
✅ Géométries complètes (centre, contour, bbox)
✅ Format JSON ou GeoJSON

⚠️ Contrainte importante

Au moins UN filtre géographique est REQUIS parmi :

code_departement
code_municipalite
code_postal
code_iris
OU la paire de coordonnées GPS (lat ET lon ensemble)

Cette contrainte permet de limiter la portée de la recherche et éviter de scanner toute la France.

Recherche par localisation

Par code postal

cURL
JavaScript
PHP
Python

curl -X GET \
  "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=75008&limite=10" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '75008',
    limite: '10',
  }),
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
    },
  }
);

const parcelles = await response.json();
console.log(parcelles);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$url = 'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' . http_build_query([
    'code_postal' => '75008',
    'limite' => 10
]);

$options = [
    'http' => [
        'header' => "Authorization: Bearer $apiKey\r\n",
        'method' => 'GET'
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$parcelles = json_decode($response, true);

print_r($parcelles);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '75008',
        'limite': 10
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelles = response.json()
print(parcelles)

Par coordonnées GPS

Rechercher les parcelles autour d'un point géographique :

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?lat=48.8698&lon=2.3080&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    lat: '48.8698',
    lon: '2.3080',
    limite: '20',
  }),
  { headers: { 'Authorization': `Bearer ${apiKey}` } }
);

const parcelles = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$params = http_build_query([
    'lat' => '48.8698',
    'lon' => '2.3080',
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$parcelles = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'lat': 48.8698,
        'lon': 2.3080,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelles = response.json()

Par commune

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=75108&limite=50" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '75108',
    limite: '50',
  }),
  { headers: { 'Authorization': `Bearer ${apiKey}` } }
);

const parcelles = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$params = http_build_query([
    'code_municipalite' => '75108',
    'limite' => 50
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$parcelles = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '75108',
        'limite': 50
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelles = response.json()

Filtrer par superficie

Trouver de grandes parcelles

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=69123&superficie_min=1000&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles de plus de 1000 m² à Lyon
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '69123',
    superficie_min: '1000',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const grandesParcelles = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles de plus de 1000 m² à Lyon
$params = http_build_query([
    'code_municipalite' => '69123',
    'superficie_min' => 1000,
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$grandesParcelles = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles de plus de 1000 m² à Lyon
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '69123',
        'superficie_min': 1000,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

grandes_parcelles = response.json()

Trouver des petites parcelles

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=13055&superficie_min=100&superficie_max=300&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles entre 100 et 300 m² à Marseille
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '13055',
    superficie_min: '100',
    superficie_max: '300',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const petitesParcelles = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles entre 100 et 300 m² à Marseille
$params = http_build_query([
    'code_municipalite' => '13055',
    'superficie_min' => 100,
    'superficie_max' => 300,
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$petitesParcelles = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles entre 100 et 300 m² à Marseille
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '13055',
        'superficie_min': 100,
        'superficie_max': 300,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

petites_parcelles = response.json()

Filtrer par type de bâti

Maisons

cURL
JavaScript
PHP
Python

# Maisons de 3 pièces et plus à Bordeaux
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=33000&bati_type=4,5,6&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Maisons de 3 pièces et plus à Bordeaux
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '33000',
    bati_type: '4,5,6',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const maisons = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Maisons de 3 pièces et plus à Bordeaux
$params = http_build_query([
    'code_postal' => '33000',
    'bati_type' => '4,5,6',
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$maisons = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Maisons de 3 pièces et plus à Bordeaux
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '33000',
        'bati_type': '4,5,6',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

maisons = response.json()

Codes des maisons :

1 - Maison (indéterminé)
2 - Maison 1 pièce/studio
3 - Maison 2 pièces
4 - Maison 3 pièces
5 - Maison 4 pièces
6 - Maison 5 pièces et plus

Appartements

cURL
JavaScript
PHP
Python

# Appartements de 2-3 pièces à Nice
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=06000&bati_type=9,10&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Appartements de 2-3 pièces à Nice
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '06000',
    bati_type: '9,10',  // Appartements 2 ou 3 pièces
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const appartements = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Appartements de 2-3 pièces à Nice
$params = http_build_query([
    'code_postal' => '06000',
    'bati_type' => '9,10',  // Appartements 2 ou 3 pièces
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$appartements = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Appartements de 2-3 pièces à Nice
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '06000',
        'bati_type': '9,10',  # Appartements 2 ou 3 pièces
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

appartements = response.json()

Codes des appartements :

7 - Appartement (indéterminé)
8 - Appartement 1 pièce/studio
9 - Appartement 2 pièces
10 - Appartement 3 pièces
11 - Appartement 4 pièces
12 - Appartement 5 pièces et plus

Terrains à bâtir

cURL
JavaScript
PHP
Python

# Terrains à bâtir à Toulouse
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=31555&bati_type=16&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Terrains à bâtir à Toulouse
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '31555',
    bati_type: '16',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const terrains = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Terrains à bâtir à Toulouse
$params = http_build_query([
    'code_municipalite' => '31555',
    'bati_type' => 16,
    'limite' => 30
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$terrains = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Terrains à bâtir à Toulouse
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '31555',
        'bati_type': 16,
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

terrains = response.json()

Filtrer par performance énergétique

Trouver des passoires thermiques

cURL
JavaScript
PHP
Python

# Parcelles avec DPE F ou G à Lille
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=59000&dpe_energie=F,G&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles avec DPE F ou G à Lille
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '59000',
    dpe_energie: 'F,G',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const passoiresThermiques = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles avec DPE F ou G à Lille
$params = http_build_query([
    'code_postal' => '59000',
    'dpe_energie' => 'F,G',
    'limite' => 30
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$passoiresThermiques = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles avec DPE F ou G à Lille
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '59000',
        'dpe_energie': 'F,G',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

passoires_thermiques = response.json()

Trouver des logements performants

cURL
JavaScript
PHP
Python

# Parcelles avec DPE A, B ou C à Strasbourg
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=67000&dpe_energie=A,B,C&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles avec DPE A, B ou C à Strasbourg
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '67000',
    dpe_energie: 'A,B,C',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const logementsPerformants = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles avec DPE A, B ou C à Strasbourg
$params = http_build_query([
    'code_postal' => '67000',
    'dpe_energie' => 'A,B,C',
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$logementsPerformants = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles avec DPE A, B ou C à Strasbourg
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '67000',
        'dpe_energie': 'A,B,C',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

logements_performants = response.json()

Étiquettes DPE :

A - ≤ 70 kWh/m²/an (Très performant)
B - 71-110 kWh/m²/an (Performant)
C - 111-180 kWh/m²/an (Assez performant)
D - 181-250 kWh/m²/an (Moyennement performant)
E - 251-330 kWh/m²/an (Peu performant)
F - 331-420 kWh/m²/an (Très peu performant)
G - > 420 kWh/m²/an (Passoire thermique)

Filtrer par transactions DVF

Parcelles récemment vendues

cURL
JavaScript
PHP
Python

# Parcelles vendues depuis 2023 à Nantes
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=44109&dvf_existe=true&dvf_date_min=2023-01-01&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles vendues depuis 2023 à Nantes
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '44109',
    dvf_existe: 'true',
    dvf_date_min: '2023-01-01',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcellesVendues = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles vendues depuis 2023 à Nantes
$params = http_build_query([
    'code_municipalite' => '44109',
    'dvf_existe' => 'true',
    'dvf_date_min' => '2023-01-01',
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$parcellesVendues = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles vendues depuis 2023 à Nantes
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '44109',
        'dvf_existe': True,
        'dvf_date_min': '2023-01-01',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelles_vendues = response.json()

Filtrer par prix de vente

cURL
JavaScript
PHP
Python

# Parcelles vendues entre 200k et 400k€ à Montpellier
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=34172&dvf_existe=true&dvf_prix_min=200000&dvf_prix_max=400000&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Parcelles vendues entre 200k et 400k€ à Montpellier
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '34172',
    dvf_existe: 'true',
    dvf_prix_min: '200000',
    dvf_prix_max: '400000',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcellesPrixMoyen = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Parcelles vendues entre 200k et 400k€ à Montpellier
$params = http_build_query([
    'code_municipalite' => '34172',
    'dvf_existe' => true,
    'dvf_prix_min' => 200000,
    'dvf_prix_max' => 400000,
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$parcellesPrixMoyen = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Parcelles vendues entre 200k et 400k€ à Montpellier
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '34172',
        'dvf_existe': True,
        'dvf_prix_min': 200000,
        'dvf_prix_max': 400000,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelles_prix_moyen = response.json()

Recherche multicritère avancée

Exemple : Maisons avec piscine

cURL
JavaScript
PHP
Python

# Maisons de 4 pièces+ avec piscine à Aix-en-Provence
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=13080&bati_type=5,6&piscine=true&superficie_min=500&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Maisons de 4 pièces+ avec piscine à Aix-en-Provence
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '13080',
    bati_type: '5,6',  // Maisons 4-5 pièces+
    piscine: 'true',
    superficie_min: '500',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const maisonsAvecPiscine = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Maisons de 4 pièces+ avec piscine à Aix-en-Provence
$params = http_build_query([
    'code_postal' => '13080',
    'bati_type' => '5,6',  // Maisons 4-5 pièces+
    'piscine' => true,
    'superficie_min' => 500,
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$maisonsAvecPiscine = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Maisons de 4 pièces+ avec piscine à Aix-en-Provence
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '13080',
        'bati_type': '5,6',  # Maisons 4-5 pièces+
        'piscine': True,
        'superficie_min': 500,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

maisons_avec_piscine = response.json()

Exemple : Appartements récents bien isolés

cURL
JavaScript
PHP
Python

# Appartements construits après 2010 avec DPE A ou B à Rennes
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_municipalite=35238&bati_type=7,8,9,10,11,12&annee_construction_min=2010&dpe_energie=A,B&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Appartements construits après 2010 avec DPE A ou B à Rennes
const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_municipalite: '35238',
    bati_type: '7,8,9,10,11,12',  // Tous types d'appartements
    annee_construction_min: '2010',
    dpe_energie: 'A,B',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const appartementsRecents = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Appartements construits après 2010 avec DPE A ou B à Rennes
$params = http_build_query([
    'code_municipalite' => '35238',
    'bati_type' => '7,8,9,10,11,12',  // Tous types d'appartements
    'annee_construction_min' => 2010,
    'dpe_energie' => 'A,B',
    'limite' => 30
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$appartementsRecents = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Appartements construits après 2010 avec DPE A ou B à Rennes
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_municipalite': '35238',
        'bati_type': '7,8,9,10,11,12',  # Tous types d'appartements
        'annee_construction_min': 2010,
        'dpe_energie': 'A,B',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

appartements_recents = response.json()

Format GeoJSON

Pour une intégration directe dans une carte (Leaflet, Mapbox, etc.) :

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=75008&format=geojson&geometrie=contour&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '75008',
    format: 'geojson',
    geometrie: 'contour',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const geoJson = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

$params = http_build_query([
    'code_postal' => '75008',
    'format' => 'geojson',
    'geometrie' => 'contour',
    'limite' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$geoJson = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '75008',
        'format': 'geojson',
        'geometrie': 'contour',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

geo_json = response.json()

Types de géométrie disponibles :

centre - Point central de la parcelle (défaut)
contour - Polygone complet de la parcelle
bbox - Boîte englobante

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [[[2.32, 48.85], [2.37, 48.85], ...]]
      },
      "properties": {
        "cadastre_id": "75108000BO0025",
        "superficie": 523.45,
        "section": {"code": "BO"},
        "municipalite": {
          "code": "75108",
          "nom": "Paris 8e Arrondissement"
        }
      }
    }
  ]
}

Pagination

Par défaut, l'API retourne 10 résultats. Vous pouvez ajuster ce nombre :

cURL
JavaScript
PHP
Python

# 50 résultats (maximum)
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=75001&limite=50" \
  -H "Authorization: Bearer VOTRE_CLE_API"

# Pagination avec offset
curl "https://app.infoparcelle.fr/api/v1/parcelles/recherche?code_postal=75001&limite=20&offset=20" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// 50 résultats (maximum)
const response1 = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '75001',
    limite: '50',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

// Pagination avec offset
const response2 = await fetch(
  'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
  new URLSearchParams({
    code_postal: '75001',
    limite: '20',
    offset: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// 50 résultats (maximum)
$params1 = http_build_query([
    'code_postal' => '75001',
    'limite' => 50
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params1");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response1 = curl_exec($ch);
curl_close($ch);

// Pagination avec offset
$params2 = http_build_query([
    'code_postal' => '75001',
    'limite' => 20,
    'offset' => 20
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params2");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response2 = curl_exec($ch);
curl_close($ch);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# 50 résultats (maximum)
response1 = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '75001',
        'limite': 50
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

# Pagination avec offset
response2 = requests.get(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
    params={
        'code_postal': '75001',
        'limite': 20,
        'offset': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

Obtenir une fiche parcelle complète

Une fois que vous avez trouvé une parcelle intéressante, utilisez son cadastre_id pour obtenir toutes les informations :

cURL
JavaScript
PHP
Python

# Obtenir la fiche complète d'une parcelle
curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Obtenir la fiche complète d'une parcelle
const cadastreId = '75108000BO0025';

const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}`,
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const ficheComplete = await response.json();

console.log('DPE:', ficheComplete.dpes);
console.log('Transactions DVF:', ficheComplete.dvfs);
console.log('Zones PLU:', ficheComplete.zones_plu);
console.log('Propriétaires:', ficheComplete.proprietaires);

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Obtenir la fiche complète d'une parcelle
$cadastreId = '75108000BO0025';

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$ficheComplete = json_decode($response, true);

echo 'DPE: ' . print_r($ficheComplete['dpes'], true) . "\n";
echo 'Transactions DVF: ' . print_r($ficheComplete['dvfs'], true) . "\n";
echo 'Zones PLU: ' . print_r($ficheComplete['zones_plu'], true) . "\n";
echo 'Propriétaires: ' . print_r($ficheComplete['proprietaires'], true) . "\n";

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Obtenir la fiche complète d'une parcelle
cadastre_id = '75108000BO0025'

response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    headers={'Authorization': f'Bearer {api_key}'}
)

fiche_complete = response.json()

print('DPE:', fiche_complete['dpes'])
print('Transactions DVF:', fiche_complete['dvfs'])
print('Zones PLU:', fiche_complete['zones_plu'])
print('Propriétaires:', fiche_complete['proprietaires'])

Personnaliser les champs retournés

cURL
JavaScript
PHP
Python

# Demander uniquement certains champs
curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,superficie,dpes,dvfs,zones_plu,centre" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Demander uniquement certains champs
const cadastreId = '75108000BO0025';

const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,superficie,dpes,dvfs,zones_plu,centre',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcellePartielle = await response.json();

<?php
$apiKey = getenv('INFOPARCELLE_API_KEY');

// Demander uniquement certains champs
$cadastreId = '75108000BO0025';
$params = http_build_query([
    'champs' => 'cadastre_id,superficie,dpes,dvfs,zones_plu,centre'
]);

$ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?$params");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $apiKey"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$parcellePartielle = json_decode($response, true);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Demander uniquement certains champs
cadastre_id = '75108000BO0025'

response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={
        'champs': 'cadastre_id,superficie,dpes,dvfs,zones_plu,centre'
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle_partielle = response.json()

Cas d'usage avancés

1. Détection d'opportunités immobilières

JavaScript
PHP
Python

// Trouver des passoires thermiques vendues récemment
async function trouverOpportunites(codePostal) {
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
    new URLSearchParams({
      code_postal: codePostal,
      dpe_energie: 'F,G',  // Passoires thermiques
      dvf_existe: 'true',  // Vendues récemment
      dvf_date_min: '2023-01-01',
      bati_type: '1,2,3,4,5,6',  // Maisons uniquement
      superficie_min: '300',
      limite: '50',
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const parcelles = await response.json();

  // Calculer le potentiel de rénovation
  return parcelles.map(p => ({
    cadastre_id: p.cadastre_id,
    adresse: p.municipalite.nom,
    superficie: p.superficie,
    dpe_actuel: p.detail?.dpe_energie,
    potentiel: 'Rénovation énergétique',
  }));
}

// Utilisation
const opportunites = await trouverOpportunites('69000');
console.log(`${opportunites.length} opportunités trouvées`);

<?php
function trouver_opportunites($code_postal, $api_key) {
    // Trouver des passoires thermiques vendues récemment
    $params = http_build_query([
        'code_postal' => $code_postal,
        'dpe_energie' => 'F,G',  // Passoires thermiques
        'dvf_existe' => 'true',  // Vendues récemment
        'dvf_date_min' => '2023-01-01',
        'bati_type' => '1,2,3,4,5,6',  // Maisons uniquement
        'superficie_min' => '300',
        'limite' => '50'
    ]);

    $ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $parcelles = json_decode($response, true);

    // Calculer le potentiel de rénovation
    $opportunites = array_map(function($p) {
        return [
            'cadastre_id' => $p['cadastre_id'],
            'adresse' => $p['municipalite']['nom'],
            'superficie' => $p['superficie'],
            'dpe_actuel' => $p['detail']['dpe_energie'] ?? null,
            'potentiel' => 'Rénovation énergétique'
        ];
    }, $parcelles);

    return $opportunites;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$opportunites = trouver_opportunites('69000', $api_key);
echo count($opportunites) . " opportunités trouvées\n";
?>

import os
import requests

def trouver_opportunites(code_postal):
    """
    Trouver des passoires thermiques vendues récemment
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
        params={
            'code_postal': code_postal,
            'dpe_energie': 'F,G',  # Passoires thermiques
            'dvf_existe': True,  # Vendues récemment
            'dvf_date_min': '2023-01-01',
            'bati_type': '1,2,3,4,5,6',  # Maisons uniquement
            'superficie_min': 300,
            'limite': 50
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    parcelles = response.json()

    # Calculer le potentiel de rénovation
    opportunites = []
    for p in parcelles:
        opportunites.append({
            'cadastre_id': p['cadastre_id'],
            'adresse': p['municipalite']['nom'],
            'superficie': p['superficie'],
            'dpe_actuel': p.get('detail', {}).get('dpe_energie'),
            'potentiel': 'Rénovation énergétique'
        })

    return opportunites

# Utilisation
opportunites = trouver_opportunites('69000')
print(f"{len(opportunites)} opportunités trouvées")

2. Analyse de marché immobilier

JavaScript
PHP
Python

async function analyserMarche(codeMunicipalite, anneeMin = 2020) {
  /**
   * Analyse le marché immobilier d'une commune
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
    new URLSearchParams({
      code_municipalite: codeMunicipalite,
      dvf_existe: 'true',
      dvf_date_min: `${anneeMin}-01-01`,
      limite: '50',
      offset: '0'
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const parcelles = await response.json();

  // Calculer les statistiques
  const stats = {
    total: parcelles.length,
    superficie_moyenne: parcelles.reduce((sum, p) => sum + p.superficie, 0) / parcelles.length,
    types_bati: {}
  };

  parcelles.forEach(p => {
    const batiType = p.detail?.caracteristiques?.bati_type;
    if (batiType) {
      stats.types_bati[batiType] = (stats.types_bati[batiType] || 0) + 1;
    }
  });

  return stats;
}

// Utilisation
const stats = await analyserMarche('75108', 2022);
console.log('Analyse de marché:', stats);

<?php
function analyser_marche($code_municipalite, $annee_min = 2020, $api_key) {
    /**
     * Analyse le marché immobilier d'une commune
     */
    $params = http_build_query([
        'code_municipalite' => $code_municipalite,
        'dvf_existe' => 'true',
        'dvf_date_min' => "$annee_min-01-01",
        'limite' => 50,
        'offset' => 0
    ]);

    $ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $parcelles = json_decode($response, true);

    // Calculer les statistiques
    $superficie_totale = array_sum(array_column($parcelles, 'superficie'));
    $stats = [
        'total' => count($parcelles),
        'superficie_moyenne' => $superficie_totale / count($parcelles),
        'types_bati' => []
    ];

    foreach ($parcelles as $p) {
        $bati_type = $p['detail']['caracteristiques']['bati_type'] ?? null;
        if ($bati_type) {
            $stats['types_bati'][$bati_type] = ($stats['types_bati'][$bati_type] ?? 0) + 1;
        }
    }

    return $stats;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$stats = analyser_marche('75108', 2022, $api_key);
print_r($stats);
?>

import os
import requests

def analyser_marche(code_municipalite, annee_min=2020):
    """
    Analyse le marché immobilier d'une commune
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
        params={
            'code_municipalite': code_municipalite,
            'dvf_existe': True,
            'dvf_date_min': f'{annee_min}-01-01',
            'limite': 50,
            'offset': 0
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    parcelles = response.json()

    # Calculer les statistiques
    stats = {
        'total': len(parcelles),
        'superficie_moyenne': sum(p['superficie'] for p in parcelles) / len(parcelles),
        'types_bati': {},
    }

    for p in parcelles:
        bati_type = p.get('detail', {}).get('caracteristiques', {}).get('bati_type')
        stats['types_bati'][bati_type] = stats['types_bati'].get(bati_type, 0) + 1

    return stats

# Utilisation
stats = analyser_marche('75108', annee_min=2022)
print(f"Analyse de marché: {stats}")

3. Recherche de terrains constructibles

JavaScript
PHP
Python

// Trouver des terrains à bâtir en zone U (urbaine)
async function rechercherTerrainsConstructibles(codePostal) {
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/parcelles/recherche?' +
    new URLSearchParams({
      code_postal: codePostal,
      bati_type: '16',  // Terrain à bâtir
      plu_zone: 'U',    // Zone urbaine
      superficie_min: '400',
      superficie_max: '2000',
      limite: '30',
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  return await response.json();
}

// Utilisation
const terrains = await rechercherTerrainsConstructibles('69000');
console.log(`${terrains.length} terrains constructibles trouvés`);

<?php
function rechercher_terrains_constructibles($code_postal, $api_key) {
    // Trouver des terrains à bâtir en zone U (urbaine)
    $params = http_build_query([
        'code_postal' => $code_postal,
        'bati_type' => '16',  // Terrain à bâtir
        'plu_zone' => 'U',    // Zone urbaine
        'superficie_min' => '400',
        'superficie_max' => '2000',
        'limite' => '30'
    ]);

    $ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/recherche?$params");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$terrains = rechercher_terrains_constructibles('69000', $api_key);
echo count($terrains) . " terrains constructibles trouvés\n";
?>

import os
import requests

def rechercher_terrains_constructibles(code_postal):
    """
    Trouver des terrains à bâtir en zone U (urbaine)
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/parcelles/recherche',
        params={
            'code_postal': code_postal,
            'bati_type': '16',  # Terrain à bâtir
            'plu_zone': 'U',    # Zone urbaine
            'superficie_min': 400,
            'superficie_max': 2000,
            'limite': 30
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    return response.json()

# Utilisation
terrains = rechercher_terrains_constructibles('69000')
print(f"{len(terrains)} terrains constructibles trouvés")

Bonnes pratiques

✅ À faire

Toujours inclure un filtre géographique (requis)
Limiter le nombre de résultats (10-50 selon vos besoins)
Utiliser la pagination pour parcourir de grands ensembles
Combiner les filtres pour affiner vos recherches
Demander uniquement les champs nécessaires avec le paramètre champs
Utiliser GeoJSON pour l'affichage cartographique
Cacher les résultats pour les recherches fréquentes

❌ À éviter

❌ Oublier le filtre géographique (erreur 400)
❌ Demander trop de résultats (limite max : 50)
❌ Ignorer la pagination pour de grands volumes
❌ Multiplier les requêtes inutiles
❌ Ne pas gérer les erreurs (timeout, quota dépassé)

Principaux filtres disponibles

Localisation

code_departement, code_municipalite, code_postal, code_iris
lat, lon (coordonnées GPS)
code_section (section cadastrale)

Superficie et surfaces

superficie_min, superficie_max
surface_habitable_min, surface_habitable_max
jardin_min, jardin_max
emprise_sol_min, emprise_sol_max

Bâti

bati_type (0-17)
construction (boolean)
annee_construction_min, annee_construction_max
etages, hauteur_min, hauteur_max
isole, mitoyen

Performance énergétique

dpe_energie (A-G)
dpe_ges (A-G)
dpe_date_reception_min, dpe_date_reception_max

Transactions DVF

dvf_existe (boolean)
dvf_prix_min, dvf_prix_max
dvf_date_min, dvf_date_max
dvf_code_type_bien

Piscine

piscine (boolean)
piscine_surface_min, piscine_surface_max
forme_piscine (0-4)

Urbanisme et risques

plu_zone, plu_zone_type
risque_argile, risque_radon (1-3)

Performances

Temps de réponse moyen : < 200ms
Cache côté serveur : 15 minutes
Rate limit : 1200 requêtes/minute

Voir aussi

Référence API - Documentation technique complète de l'API
Transactions DVF - Rechercher les ventes immobilières
Performance énergétique - Rechercher les DPE
Gestion des erreurs - Gérer les erreurs

Vue d'ensemble​

Fonctionnalités principales​

⚠️ Contrainte importante​

Recherche par localisation​

Par code postal​

Par coordonnées GPS​

Par commune​

Filtrer par superficie​

Trouver de grandes parcelles​

Trouver des petites parcelles​

Filtrer par type de bâti​

Maisons​

Appartements​

Terrains à bâtir​

Filtrer par performance énergétique​

Trouver des passoires thermiques​

Trouver des logements performants​

Filtrer par transactions DVF​

Parcelles récemment vendues​

Filtrer par prix de vente​

Recherche multicritère avancée​

Exemple : Maisons avec piscine​

Exemple : Appartements récents bien isolés​

Format GeoJSON​

Pagination​

Obtenir une fiche parcelle complète​

Personnaliser les champs retournés​

Cas d'usage avancés​

1. Détection d'opportunités immobilières​

2. Analyse de marché immobilier​

3. Recherche de terrains constructibles​

Bonnes pratiques​

✅ À faire​

❌ À éviter​

Principaux filtres disponibles​

Localisation​

Superficie et surfaces​

Bâti​

Performance énergétique​

Transactions DVF​

Piscine​

Urbanisme et risques​

Performances​

Voir aussi​