Rechercher des Diagnostics de Performance Énergétique (DPE)

L'API Infoparcelle donne accès à la base de données complète des Diagnostics de Performance Énergétique (DPE) de l'ADEME. Ce guide vous explique comment rechercher et analyser les performances énergétiques des logements français.

Vue d'ensemble

L'endpoint /api/v1/dpes permet de rechercher des DPE par différents critères : localisation, étiquettes énergétiques, type de bâtiment, année de construction, consommation, etc.

Fonctionnalités principales

✅ Accès à tous les DPE officiels (ADEME)
✅ Filtrage par étiquettes énergétiques (A à G)
✅ Filtrage par étiquettes GES (A à G)
✅ Filtrage par type de bâtiment (maison, appartement, immeuble)
✅ Filtrage par performances énergétiques
✅ Données de consommation et coûts détaillés
✅ Format JSON ou GeoJSON
✅ Pagination par curseur

Qu'est-ce qu'un DPE ?

Le DPE (Diagnostic de Performance Énergétique) est un document qui évalue :

🔥 Consommation énergétique : Chauffage, eau chaude, refroidissement, éclairage
🌍 Émissions de gaz à effet de serre (GES) : Impact environnemental
💰 Coûts énergétiques annuels : Estimation des dépenses
📊 Étiquettes énergétiques : De A (excellent) à G (passoire thermique)

Recherche basique

Par code postal

cURL
JavaScript
PHP
Python

curl -X GET \
  "https://app.infoparcelle.fr/api/v1/dpes?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/dpes?' +
  new URLSearchParams({
    code_postal: '75008',
    limite: '10',
  }),
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
    },
  }
);

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

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . 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);
$data = json_decode($response, true);

print_r($data);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

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

dpes = response.json()
print(dpes)

Par commune

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=69123&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/dpes?' +
  new URLSearchParams({
    code_municipalite: '69123',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpes = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '69123',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '69123',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes = response.json()

Par coordonnées GPS

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?lat=48.8566&lon=2.3522&limite=15" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    lat: '48.8566',
    lon: '2.3522',
    limite: '15',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesProximite = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'lat' => '48.8566',
    'lon' => '2.3522',
    'limite' => '15'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesProximite = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'lat': '48.8566',
        'lon': '2.3522',
        'limite': 15
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_proximite = response.json()

Filtrer par étiquette énergétique

Trouver les passoires thermiques

Les passoires thermiques sont les logements avec étiquettes F ou G (forte consommation énergétique).

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=13001&etiquette_dpe=F,G&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_postal: '13001',
    etiquette_dpe: 'F,G',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const passoiresThermiques = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '13001',
    'etiquette_dpe' => 'F,G',
    'limite' => '30'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$passoiresThermiques = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '13001',
        'etiquette_dpe': 'F,G',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

passoires_thermiques = response.json()

Étiquettes DPE énergie :

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)

Trouver les logements performants

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=33000&etiquette_dpe=A,B,C&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/dpes?' +
  new URLSearchParams({
    code_postal: '33000',
    etiquette_dpe: 'A,B,C',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const logementsPerformants = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '33000',
    'etiquette_dpe' => 'A,B,C',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$logementsPerformants = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '33000',
        'etiquette_dpe': 'A,B,C',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

logements_performants = response.json()

Filtrer par émissions de GES

Les émissions de gaz à effet de serre mesurent l'impact environnemental du logement.

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=69123&etiquette_ges=F,G&limite=25" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_municipalite: '69123',
    etiquette_ges: 'F,G',
    limite: '25',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const logementsPolluants = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '69123',
    'etiquette_ges' => 'F,G',
    'limite' => '25'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$logementsPolluants = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '69123',
        'etiquette_ges': 'F,G',
        'limite': 25
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

logements_polluants = response.json()

Étiquettes GES :

A - ≤ 6 kg CO2/m²/an (Très faible émission)
B - 7-11 kg CO2/m²/an (Faible émission)
C - 12-30 kg CO2/m²/an (Émission modérée)
D - 31-50 kg CO2/m²/an (Émission moyenne)
E - 51-70 kg CO2/m²/an (Émission importante)
F - 71-100 kg CO2/m²/an (Émission très importante)
G - > 100 kg CO2/m²/an (Émission extrêmement importante)

Filtrer par type de bâtiment

Appartements

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=06000&type_batiment=appartement&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/dpes?' +
  new URLSearchParams({
    code_postal: '06000',
    type_batiment: 'appartement',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpes = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '06000',
    'type_batiment' => 'appartement',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '06000',
        'type_batiment': 'appartement',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes = response.json()

Maisons

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=31555&type_batiment=maison&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_municipalite: '31555',
    type_batiment: 'maison',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesMaisons = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '31555',
    'type_batiment' => 'maison',
    'limite' => '30'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesMaisons = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '31555',
        'type_batiment': 'maison',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_maisons = response.json()

Types de bâtiments :

appartement - Logement dans un immeuble collectif
maison - Logement individuel
immeuble - Bâtiment collectif complet

Filtrage détaillé par type de bâti

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=44000&bati_type=10&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/dpes?' +
  new URLSearchParams({
    code_postal: '44000',
    bati_type: '10',  // Appartement 3 pièces
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpes3Pieces = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '44000',
    'bati_type' => '10',  // Appartement 3 pièces
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpes3Pieces = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '44000',
        'bati_type': '10',  # Appartement 3 pièces
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_3_pieces = response.json()

Codes de bâti détaillés :

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 :

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

Filtrer par consommation énergétique

Par consommation totale

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=59000&conso_energie_min=150&conso_energie_max=250&limite=25" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_postal: '59000',
    conso_energie_min: '150',
    conso_energie_max: '250',
    limite: '25',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesConsoMoyenne = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '59000',
    'conso_energie_min' => '150',
    'conso_energie_max' => '250',
    'limite' => '25'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesConsoMoyenne = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '59000',
        'conso_energie_min': 150,
        'conso_energie_max': 250,
        'limite': 25
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_conso_moyenne = response.json()

Par émissions de GES

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=67000&emission_ges_max=30&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/dpes?' +
  new URLSearchParams({
    code_postal: '67000',
    emission_ges_max: '30',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesFaibleEmission = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '67000',
    'emission_ges_max' => '30',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesFaibleEmission = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '67000',
        'emission_ges_max': 30,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_faible_emission = response.json()

Filtrer par coût énergétique

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=34172&cout_total_max=1500&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/dpes?' +
  new URLSearchParams({
    code_municipalite: '34172',
    cout_total_max: '1500',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesEconomiques = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '34172',
    'cout_total_max' => '1500',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesEconomiques = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '34172',
        'cout_total_max': 1500,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_economiques = response.json()

Filtrer par année de construction

Bâtiments anciens

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=75056&annee_construction_max=1950&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_municipalite: '75056',
    annee_construction_max: '1950',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const batimentsAnciens = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '75056',
    'annee_construction_max' => '1950',
    'limite' => '30'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$batimentsAnciens = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '75056',
        'annee_construction_max': 1950,
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

batiments_anciens = response.json()

Bâtiments récents

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=35000&annee_construction_min=2010&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/dpes?' +
  new URLSearchParams({
    code_postal: '35000',
    annee_construction_min: '2010',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const batimentsRecents = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '35000',
    'annee_construction_min' => '2010',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$batimentsRecents = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '35000',
        'annee_construction_min': 2010,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

batiments_recents = response.json()

Filtrer par surface

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=13080&type_batiment=appartement&surface_habitable_min=60&surface_habitable_max=100&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/dpes?' +
  new URLSearchParams({
    code_postal: '13080',
    type_batiment: 'appartement',
    surface_habitable_min: '60',
    surface_habitable_max: '100',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpes = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '13080',
    'type_batiment' => 'appartement',
    'surface_habitable_min' => '60',
    'surface_habitable_max' => '100',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$data = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '13080',
        'type_batiment': 'appartement',
        'surface_habitable_min': 60,
        'surface_habitable_max': 100,
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes = response.json()

Filtrer par date de DPE

DPE récents

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_municipalite=44109&date_reception_dpe_min=2024-01-01&limite=30" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

const response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?' +
  new URLSearchParams({
    code_municipalite: '44109',
    date_reception_dpe_min: '2024-01-01',
    limite: '30',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesRecents = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_municipalite' => '44109',
    'date_reception_dpe_min' => '2024-01-01',
    'limite' => '30'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesRecents = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_municipalite': '44109',
        'date_reception_dpe_min': '2024-01-01',
        'limite': 30
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_recents = response.json()

Type de DPE

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=69000&type_dpe=0&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/dpes?' +
  new URLSearchParams({
    code_postal: '69000',
    type_dpe: '0',  // 0=Existant, 1=Neuf, 2=Tertiaire
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesExistants = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '69000',
    'type_dpe' => '0',  // 0=Existant, 1=Neuf, 2=Tertiaire
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesExistants = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '69000',
        'type_dpe': 0,  # 0=Existant, 1=Neuf, 2=Tertiaire
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_existants = response.json()

Types de DPE :

0 - Existant : DPE pour un logement existant
1 - Neuf : DPE pour une construction neuve
2 - Tertiaire : DPE pour un bâtiment tertiaire

Tri et pagination

Trier les résultats

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=75008&champ_tri=conso_energie&ordre_tri=desc&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/dpes?' +
  new URLSearchParams({
    code_postal: '75008',
    champ_tri: 'conso_energie',
    ordre_tri: 'desc',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpesTriés = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '75008',
    'champ_tri' => 'conso_energie',
    'ordre_tri' => 'desc',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpesTriés = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '75008',
        'champ_tri': 'conso_energie',
        'ordre_tri': 'desc',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes_tries = response.json()

Champs de tri disponibles :

numero_dpe - Numéro unique
date_etablissement - Date d'établissement
date_reception - Date de réception (défaut)
date_visite - Date de visite
etiquette_dpe - Étiquette énergétique
etiquette_ges - Étiquette GES
annee_construction - Année de construction
surface_habitable - Surface habitable
conso_energie - Consommation énergétique
emission_ges - Émissions de GES

Pagination avec curseur

cURL
JavaScript
PHP
Python

# Page 1
curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=75001&limite=20" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -i

# Page 2 (utilisez le curseur retourné dans X-Pagination-Next-Cursor)
curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=75001&limite=20&curseur=CURSEUR" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;

// Page 1
let response = await fetch(
  'https://app.infoparcelle.fr/api/v1/dpes?code_postal=75001&limite=20',
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

let dpes = await response.json();
let nextCursor = response.headers.get('X-Pagination-Next-Cursor');
let hasMore = response.headers.get('X-Pagination-Has-More');

// Page 2
if (hasMore === 'true' && nextCursor) {
  response = await fetch(
    `https://app.infoparcelle.fr/api/v1/dpes?code_postal=75001&limite=20&curseur=${nextCursor}`,
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const dpesPage2 = await response.json();
  dpes = [...dpes, ...dpesPage2];
}

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

// Page 1
$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '75001',
    'limite' => '20'
]);

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

$response = file_get_contents($url, false, $context);
$dpes = json_decode($response, true);

// Récupérer les en-têtes de pagination
$headers = $http_response_header;
$nextCursor = null;
foreach ($headers as $header) {
    if (strpos($header, 'X-Pagination-Next-Cursor:') === 0) {
        $nextCursor = trim(substr($header, 26));
    }
}

// Page 2
if ($nextCursor) {
    $url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
        'code_postal' => '75001',
        'limite' => '20',
        'curseur' => $nextCursor
    ]);

    $response2 = file_get_contents($url, false, $context);
    $dpesPage2 = json_decode($response2, true);
    $dpes = array_merge($dpes, $dpesPage2);
}
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

# Page 1
response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '75001',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes = response.json()
next_cursor = response.headers.get('X-Pagination-Next-Cursor')
has_more = response.headers.get('X-Pagination-Has-More')

# Page 2
if has_more == 'true' and next_cursor:
    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dpes',
        params={
            'code_postal': '75001',
            'limite': 20,
            'curseur': next_cursor
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    dpes_page_2 = response.json()
    dpes.extend(dpes_page_2)

Format GeoJSON

Pour afficher les DPE sur une carte :

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=75008&format=geojson&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/dpes?' +
  new URLSearchParams({
    code_postal: '75008',
    format: 'geojson',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const geojson = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '75008',
    'format' => 'geojson',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$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/dpes',
    params={
        'code_postal': '75008',
        'format': 'geojson',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

geojson = response.json()

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [2.3522, 48.8566]
      },
      "properties": {
        "numero_dpe": "2312345678901",
        "etiquette_dpe": "C",
        "etiquette_ges": "D",
        "type_batiment": "appartement",
        "surface_habitable": 75.5,
        "conso_energie": 185.4,
        "emission_ges": 32.8,
        "cout_total": 1450
      }
    }
  ]
}

Personnaliser les champs retournés

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/dpes?code_postal=75008&champs=numero_dpe,etiquette_dpe,etiquette_ges,conso_energie,cout_total,municipalite&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/dpes?' +
  new URLSearchParams({
    code_postal: '75008',
    champs: 'numero_dpe,etiquette_dpe,etiquette_ges,conso_energie,cout_total,municipalite',
    limite: '20',
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const dpes = await response.json();

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

$url = 'https://app.infoparcelle.fr/api/v1/dpes?' . http_build_query([
    'code_postal' => '75008',
    'champs' => 'numero_dpe,etiquette_dpe,etiquette_ges,conso_energie,cout_total,municipalite',
    'limite' => '20'
]);

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

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$dpes = json_decode($response, true);
?>

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')

response = requests.get(
    'https://app.infoparcelle.fr/api/v1/dpes',
    params={
        'code_postal': '75008',
        'champs': 'numero_dpe,etiquette_dpe,etiquette_ges,conso_energie,cout_total,municipalite',
        'limite': 20
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

dpes = response.json()

Champs disponibles :

numero_dpe - Numéro unique
type_dpe - Type de DPE
date_etablissement, date_reception, date_visite, date_fin_validite
version - Version du DPE
etiquette_dpe, etiquette_ges
adresse - Adresse du bien
type_batiment, bati_type
annee_construction, periode_construction
surface_habitable, nombre_niveau_logement, hauteur_sous_plafond
conso_energie, conso_chauffage, conso_ecs, conso_refroidissement, conso_eclairage
emission_ges, emission_ges_chauffage, emission_ges_ecs
cout_total, cout_chauffage, cout_ecs
parcelles - Parcelles cadastrales (max 10)
municipalite - Informations commune
centre - Point GPS

Cas d'usage avancés

1. Cartographie des passoires thermiques

JavaScript
PHP
Python

async function cartographierPassoiresThermiques(codeMunicipalite) {
  /**
   * Cartographie les passoires thermiques d'une commune
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/dpes?' +
    new URLSearchParams({
      code_municipalite: codeMunicipalite,
      etiquette_dpe: 'F,G',
      format: 'geojson',
      limite: '50'
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const geojson = await response.json();

  // Statistiques
  const total = geojson.features.length;
  const parEtiquette = { F: 0, G: 0 };

  geojson.features.forEach(feature => {
    const etiquette = feature.properties.etiquette_dpe;
    parEtiquette[etiquette] = (parEtiquette[etiquette] || 0) + 1;
  });

  return {
    geojson,
    total,
    repartition: parEtiquette
  };
}

// Utilisation
const resultat = await cartographierPassoiresThermiques('75108');
console.log(`Total passoires: ${resultat.total}`);
console.log(`Étiquette F: ${resultat.repartition.F}`);
console.log(`Étiquette G: ${resultat.repartition.G}`);

<?php
function cartographier_passoires_thermiques($code_municipalite, $api_key) {
    /**
     * Cartographie les passoires thermiques d'une commune
     */
    $params = http_build_query([
        'code_municipalite' => $code_municipalite,
        'etiquette_dpe' => 'F,G',
        'format' => 'geojson',
        'limite' => '50'
    ]);

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

    $geojson = json_decode($response, true);

    // Statistiques
    $total = count($geojson['features']);
    $par_etiquette = ['F' => 0, 'G' => 0];

    foreach ($geojson['features'] as $feature) {
        $etiquette = $feature['properties']['etiquette_dpe'];
        $par_etiquette[$etiquette] = ($par_etiquette[$etiquette] ?? 0) + 1;
    }

    return [
        'geojson' => $geojson,
        'total' => $total,
        'repartition' => $par_etiquette
    ];
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$resultat = cartographier_passoires_thermiques('75108', $api_key);
echo "Total passoires: {$resultat['total']}\n";
echo "Étiquette F: {$resultat['repartition']['F']}\n";
echo "Étiquette G: {$resultat['repartition']['G']}\n";
?>

import os
import requests

def cartographier_passoires_thermiques(code_municipalite):
    """
    Cartographie les passoires thermiques d'une commune
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dpes',
        params={
            'code_municipalite': code_municipalite,
            'etiquette_dpe': 'F,G',
            'format': 'geojson',
            'limite': 50
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    geojson = response.json()

    # Statistiques
    total = len(geojson['features'])
    par_etiquette = {'F': 0, 'G': 0}

    for feature in geojson['features']:
        etiquette = feature['properties']['etiquette_dpe']
        par_etiquette[etiquette] = par_etiquette.get(etiquette, 0) + 1

    return {
        'geojson': geojson,
        'total': total,
        'repartition': par_etiquette
    }

# Utilisation
resultat = cartographier_passoires_thermiques('75108')
print(f"Total passoires: {resultat['total']}")
print(f"Étiquette F: {resultat['repartition']['F']}")
print(f"Étiquette G: {resultat['repartition']['G']}")

2. Analyse du parc immobilier

JavaScript
PHP
Python

async function analyserParcImmobilier(codePostal) {
  /**
   * Analyser la qualité énergétique du parc immobilier
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

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

  const dpes = await response.json();

  // Répartition par étiquette
  const repartition = { A: 0, B: 0, C: 0, D: 0, E: 0, F: 0, G: 0 };
  dpes.forEach(dpe => {
    if (dpe.etiquette_dpe) {
      repartition[dpe.etiquette_dpe]++;
    }
  });

  // Calculs
  const total = dpes.length;
  const passoiresThermiques = repartition.F + repartition.G;
  const performants = repartition.A + repartition.B + repartition.C;
  const consoMoyenne = dpes.reduce((sum, dpe) => sum + (dpe.conso_energie || 0), 0) / total;
  const coutMoyen = dpes.reduce((sum, dpe) => sum + (dpe.cout_total || 0), 0) / total;

  return {
    total,
    repartition,
    passoiresThermiques,
    tauxPassoires: (passoiresThermiques / total * 100).toFixed(1) + '%',
    performants,
    tauxPerformants: (performants / total * 100).toFixed(1) + '%',
    consoMoyenne: Math.round(consoMoyenne),
    coutMoyen: Math.round(coutMoyen),
  };
}

// Utilisation
const analyse = await analyserParcImmobilier('75008');
console.log('Analyse du parc immobilier:');
console.log(`  Total DPE: ${analyse.total}`);
console.log(`  Passoires thermiques (F+G): ${analyse.passoiresThermiques} (${analyse.tauxPassoires})`);
console.log(`  Performants (A+B+C): ${analyse.performants} (${analyse.tauxPerformants})`);
console.log(`  Consommation moyenne: ${analyse.consoMoyenne} kWh/m²/an`);
console.log(`  Coût moyen: ${analyse.coutMoyen} €/an`);

<?php
function analyser_parc_immobilier($code_postal, $api_key) {
    /**
     * Analyser la qualité énergétique du parc immobilier
     */
    $params = http_build_query([
        'code_postal' => $code_postal,
        'limite' => '50'
    ]);

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

    $dpes = json_decode($response, true);

    // Répartition par étiquette
    $repartition = ['A' => 0, 'B' => 0, 'C' => 0, 'D' => 0, 'E' => 0, 'F' => 0, 'G' => 0];
    foreach ($dpes as $dpe) {
        if (!empty($dpe['etiquette_dpe'])) {
            $repartition[$dpe['etiquette_dpe']]++;
        }
    }

    // Calculs
    $total = count($dpes);
    $passoires_thermiques = $repartition['F'] + $repartition['G'];
    $performants = $repartition['A'] + $repartition['B'] + $repartition['C'];
    $conso_moyenne = array_sum(array_column($dpes, 'conso_energie')) / $total;
    $cout_moyen = array_sum(array_column($dpes, 'cout_total')) / $total;

    return [
        'total' => $total,
        'repartition' => $repartition,
        'passoires_thermiques' => $passoires_thermiques,
        'taux_passoires' => round(($passoires_thermiques / $total * 100), 1) . '%',
        'performants' => $performants,
        'taux_performants' => round(($performants / $total * 100), 1) . '%',
        'conso_moyenne' => round($conso_moyenne),
        'cout_moyen' => round($cout_moyen)
    ];
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$analyse = analyser_parc_immobilier('75008', $api_key);
echo "Analyse du parc immobilier:\n";
echo "  Total DPE: {$analyse['total']}\n";
echo "  Passoires thermiques (F+G): {$analyse['passoires_thermiques']} ({$analyse['taux_passoires']})\n";
echo "  Performants (A+B+C): {$analyse['performants']} ({$analyse['taux_performants']})\n";
echo "  Consommation moyenne: {$analyse['conso_moyenne']} kWh/m²/an\n";
echo "  Coût moyen: {$analyse['cout_moyen']} €/an\n";
?>

import os
import requests

def analyser_parc_immobilier(code_postal):
    """
    Analyser la qualité énergétique du parc immobilier
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

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

    dpes = response.json()

    # Répartition par étiquette
    repartition = { 'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0 }
    for dpe in dpes:
        if dpe.get('etiquette_dpe'):
            repartition[dpe['etiquette_dpe']] += 1

    # Calculs
    total = len(dpes)
    passoires_thermiques = repartition['F'] + repartition['G']
    performants = repartition['A'] + repartition['B'] + repartition['C']
    conso_moyenne = sum(dpe.get('conso_energie', 0) for dpe in dpes) / total
    cout_moyen = sum(dpe.get('cout_total', 0) for dpe in dpes) / total

    return {
        'total': total,
        'repartition': repartition,
        'passoires_thermiques': passoires_thermiques,
        'taux_passoires': f"{(passoires_thermiques / total * 100):.1f}%",
        'performants': performants,
        'taux_performants': f"{(performants / total * 100):.1f}%",
        'conso_moyenne': round(conso_moyenne),
        'cout_moyen': round(cout_moyen)
    }

# Utilisation
analyse = analyser_parc_immobilier('75008')
print('Analyse du parc immobilier:')
print(f"  Total DPE: {analyse['total']}")
print(f"  Passoires thermiques (F+G): {analyse['passoires_thermiques']} ({analyse['taux_passoires']})")
print(f"  Performants (A+B+C): {analyse['performants']} ({analyse['taux_performants']})")
print(f"  Consommation moyenne: {analyse['conso_moyenne']} kWh/m²/an")
print(f"  Coût moyen: {analyse['cout_moyen']} €/an")

3. Détection d'opportunités de rénovation

JavaScript
PHP
Python

async function detecterOpportunitesRenovation(codePostal) {
  /**
   * Détecte les opportunités de rénovation énergétique
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  // Rechercher les passoires thermiques récentes
  const response = await fetch(
    'https://app.infoparcelle.fr/api/v1/dpes?' +
    new URLSearchParams({
      code_postal: codePostal,
      etiquette_dpe: 'F,G',
      date_reception_dpe_min: '2023-01-01',
      type_batiment: 'maison',
      limite: '50'
    }),
    {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    }
  );

  const dpes = await response.json();

  const opportunites = dpes.map(dpe => {
    // Calculer le potentiel de gain
    const consoActuelle = dpe.conso_energie || 0;
    const coutActuel = dpe.cout_total || 0;

    // Estimer après rénovation (passage en C)
    const consoCible = 145;  // Milieu de l'étiquette C
    const reductionConso = consoActuelle - consoCible;
    const economieAnnuelle = coutActuel * (reductionConso / consoActuelle);

    return {
      numero_dpe: dpe.numero_dpe,
      adresse: dpe.adresse,
      etiquette_actuelle: dpe.etiquette_dpe,
      conso_actuelle: consoActuelle,
      cout_actuel: coutActuel,
      economie_potentielle: Math.round(economieAnnuelle),
      reduction_conso: Math.round(reductionConso)
    };
  });

  return opportunites.sort((a, b) => b.economie_potentielle - a.economie_potentielle);
}

// Utilisation
const opportunites = await detecterOpportunitesRenovation('69000');
console.log('Top 5 opportunités de rénovation:');
opportunites.slice(0, 5).forEach((opp, i) => {
  console.log(`${i + 1}. ${opp.adresse}`);
  console.log(`   Étiquette: ${opp.etiquette_actuelle}`);
  console.log(`   Économie potentielle: ${opp.economie_potentielle} €/an`);
  console.log(`   Réduction conso: ${opp.reduction_conso} kWh/m²/an`);
});

<?php
function detecter_opportunites_renovation($code_postal, $api_key) {
    /**
     * Détecte les opportunités de rénovation énergétique
     */
    // Rechercher les passoires thermiques récentes
    $params = http_build_query([
        'code_postal' => $code_postal,
        'etiquette_dpe' => 'F,G',
        'date_reception_dpe_min' => '2023-01-01',
        'type_batiment' => 'maison',
        'limite' => '50'
    ]);

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

    $dpes = json_decode($response, true);

    $opportunites = [];
    foreach ($dpes as $dpe) {
        // Calculer le potentiel de gain
        $conso_actuelle = $dpe['conso_energie'] ?? 0;
        $cout_actuel = $dpe['cout_total'] ?? 0;

        // Estimer après rénovation (passage en C)
        $conso_cible = 145;  // Milieu de l'étiquette C
        $reduction_conso = $conso_actuelle - $conso_cible;
        $economie_annuelle = $cout_actuel * ($reduction_conso / $conso_actuelle);

        $opportunites[] = [
            'numero_dpe' => $dpe['numero_dpe'],
            'adresse' => $dpe['adresse'] ?? '',
            'etiquette_actuelle' => $dpe['etiquette_dpe'],
            'conso_actuelle' => $conso_actuelle,
            'cout_actuel' => $cout_actuel,
            'economie_potentielle' => round($economie_annuelle),
            'reduction_conso' => round($reduction_conso)
        ];
    }

    usort($opportunites, fn($a, $b) => $b['economie_potentielle'] - $a['economie_potentielle']);
    return $opportunites;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$opportunites = detecter_opportunites_renovation('69000', $api_key);
echo "Top 5 opportunités de rénovation:\n";
foreach (array_slice($opportunites, 0, 5) as $i => $opp) {
    echo ($i + 1) . ". {$opp['adresse']}\n";
    echo "   Étiquette: {$opp['etiquette_actuelle']}\n";
    echo "   Économie potentielle: {$opp['economie_potentielle']} €/an\n";
    echo "   Réduction conso: {$opp['reduction_conso']} kWh/m²/an\n";
}
?>

import os
import requests

def detecter_opportunites_renovation(code_postal):
    """
    Détecte les opportunités de rénovation énergétique
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

    # Rechercher les passoires thermiques récentes
    response = requests.get(
        'https://app.infoparcelle.fr/api/v1/dpes',
        params={
            'code_postal': code_postal,
            'etiquette_dpe': 'F,G',
            'date_reception_dpe_min': '2023-01-01',
            'type_batiment': 'maison',
            'limite': 50
        },
        headers={'Authorization': f'Bearer {api_key}'}
    )

    dpes = response.json()

    opportunites = []
    for dpe in dpes:
        # Calculer le potentiel de gain
        conso_actuelle = dpe.get('conso_energie', 0)
        cout_actuel = dpe.get('cout_total', 0)

        # Estimer après rénovation (passage en C)
        conso_cible = 145  # Milieu de l'étiquette C
        reduction_conso = conso_actuelle - conso_cible
        economie_annuelle = cout_actuel * (reduction_conso / conso_actuelle)

        opportunites.append({
            'numero_dpe': dpe['numero_dpe'],
            'adresse': dpe.get('adresse'),
            'etiquette_actuelle': dpe['etiquette_dpe'],
            'conso_actuelle': conso_actuelle,
            'cout_actuel': cout_actuel,
            'economie_potentielle': round(economie_annuelle),
            'reduction_conso': round(reduction_conso),
        })

    return sorted(opportunites, key=lambda x: x['economie_potentielle'], reverse=True)

# Utilisation
opportunites = detecter_opportunites_renovation('69000')
print(f"Top 5 opportunités de rénovation:")
for i, opp in enumerate(opportunites[:5], 1):
    print(f"{i}. {opp['adresse']}")
    print(f"   Étiquette: {opp['etiquette_actuelle']}")
    print(f"   Économie potentielle: {opp['economie_potentielle']} €/an")
    print(f"   Réduction conso: {opp['reduction_conso']} kWh/m²/an")

4. Comparaison entre types de bâtiments

JavaScript
PHP
Python

async function comparerTypesBuildings(codePostal) {
  /**
   * Comparer les performances entre maisons et appartements
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;
  const types = ['maison', 'appartement'];
  const resultats = {};

  for (const type of types) {
    const response = await fetch(
      'https://app.infoparcelle.fr/api/v1/dpes?' +
      new URLSearchParams({
        code_postal: codePostal,
        type_batiment: type,
        limite: '50',
      }),
      {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      }
    );

    const dpes = await response.json();

    const consoMoyenne = dpes.reduce((sum, d) => sum + (d.conso_energie || 0), 0) / dpes.length;
    const coutMoyen = dpes.reduce((sum, d) => sum + (d.cout_total || 0), 0) / dpes.length;
    const emissionMoyenne = dpes.reduce((sum, d) => sum + (d.emission_ges || 0), 0) / dpes.length;

    resultats[type] = {
      total: dpes.length,
      consoMoyenne: Math.round(consoMoyenne),
      coutMoyen: Math.round(coutMoyen),
      emissionMoyenne: Math.round(emissionMoyenne),
    };
  }

  return resultats;
}

// Utilisation
const comparaison = await comparerTypesBuildings('75008');
console.table(comparaison);

<?php
function comparer_types_buildings($code_postal, $api_key) {
    /**
     * Comparer les performances entre maisons et appartements
     */
    $types = ['maison', 'appartement'];
    $resultats = [];

    foreach ($types as $type) {
        $params = http_build_query([
            'code_postal' => $code_postal,
            'type_batiment' => $type,
            'limite' => '50'
        ]);

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

        $dpes = json_decode($response, true);

        $conso_moyenne = array_sum(array_column($dpes, 'conso_energie')) / count($dpes);
        $cout_moyen = array_sum(array_column($dpes, 'cout_total')) / count($dpes);
        $emission_moyenne = array_sum(array_column($dpes, 'emission_ges')) / count($dpes);

        $resultats[$type] = [
            'total' => count($dpes),
            'conso_moyenne' => round($conso_moyenne),
            'cout_moyen' => round($cout_moyen),
            'emission_moyenne' => round($emission_moyenne)
        ];
    }

    return $resultats;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$comparaison = comparer_types_buildings('75008', $api_key);
foreach ($comparaison as $type => $data) {
    echo "$type:\n";
    echo "  Total: {$data['total']}\n";
    echo "  Conso moyenne: {$data['conso_moyenne']} kWh/m²/an\n";
    echo "  Coût moyen: {$data['cout_moyen']} €/an\n";
    echo "  Émission moyenne: {$data['emission_moyenne']} kg CO2/m²/an\n\n";
}
?>

import os
import requests

def comparer_types_buildings(code_postal):
    """
    Comparer les performances entre maisons et appartements
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')
    types = ['maison', 'appartement']
    resultats = {}

    for type_batiment in types:
        response = requests.get(
            'https://app.infoparcelle.fr/api/v1/dpes',
            params={
                'code_postal': code_postal,
                'type_batiment': type_batiment,
                'limite': 50
            },
            headers={'Authorization': f'Bearer {api_key}'}
        )

        dpes = response.json()

        conso_moyenne = sum(d.get('conso_energie', 0) for d in dpes) / len(dpes)
        cout_moyen = sum(d.get('cout_total', 0) for d in dpes) / len(dpes)
        emission_moyenne = sum(d.get('emission_ges', 0) for d in dpes) / len(dpes)

        resultats[type_batiment] = {
            'total': len(dpes),
            'conso_moyenne': round(conso_moyenne),
            'cout_moyen': round(cout_moyen),
            'emission_moyenne': round(emission_moyenne)
        }

    return resultats

# Utilisation
comparaison = comparer_types_buildings('75008')
for type_batiment, data in comparaison.items():
    print(f"{type_batiment}:")
    print(f"  Total: {data['total']}")
    print(f"  Conso moyenne: {data['conso_moyenne']} kWh/m²/an")
    print(f"  Coût moyen: {data['cout_moyen']} €/an")
    print(f"  Émission moyenne: {data['emission_moyenne']} kg CO2/m²/an\n")

Bonnes pratiques

✅ À faire

Filtrer par localisation (code postal ou commune)
Combiner les filtres (étiquette + type + surface)
Utiliser la pagination pour de grands volumes
Vérifier la date de validité des DPE (valides 10 ans)
Analyser les consommations détaillées (chauffage, ECS, etc.)
Calculer les économies potentielles après rénovation
Demander uniquement les champs nécessaires
Cacher les résultats pour les recherches fréquentes

❌ À éviter

❌ Ignorer le type de DPE (existant vs neuf)
❌ Ne pas vérifier la date de validité
❌ Oublier la pagination (limite max : 50)
❌ Ne pas gérer les valeurs nulles
❌ Ignorer les différences entre étiquettes DPE et GES

Limites et précisions

DPE valides 10 ans : Vérifier la date_fin_validite
Champ parcelles limité à 10 parcelles par DPE
Maximum 50 résultats par requête (utilisez la pagination)
Certains champs peuvent être null selon le type de DPE
Les DPE avant 2021 peuvent avoir des données moins complètes (ancienne méthode)

Performances

Temps de réponse moyen : < 150ms
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
Parcelles cadastrales - Rechercher les parcelles
Transactions DVF - Rechercher les ventes
Gestion des erreurs - Gérer les erreurs

Vue d'ensemble​

Fonctionnalités principales​

Qu'est-ce qu'un DPE ?​

Recherche basique​

Par code postal​

Par commune​

Par coordonnées GPS​

Filtrer par étiquette énergétique​

Trouver les passoires thermiques​

Trouver les logements performants​

Filtrer par émissions de GES​

Filtrer par type de bâtiment​

Appartements​

Maisons​

Filtrage détaillé par type de bâti​

Filtrer par consommation énergétique​

Par consommation totale​

Par émissions de GES​

Filtrer par coût énergétique​

Filtrer par année de construction​

Bâtiments anciens​

Bâtiments récents​

Filtrer par surface​

Filtrer par date de DPE​

DPE récents​

Type de DPE​

Tri et pagination​

Trier les résultats​

Pagination avec curseur​

Format GeoJSON​

Personnaliser les champs retournés​

Cas d'usage avancés​

1. Cartographie des passoires thermiques​

2. Analyse du parc immobilier​

3. Détection d'opportunités de rénovation​

4. Comparaison entre types de bâtiments​

Bonnes pratiques​

✅ À faire​

❌ À éviter​

Limites et précisions​

Performances​

Voir aussi​