Obtenir une fiche parcelle complète

Une fois que vous avez trouvé une parcelle intéressante via la recherche, l'API Infoparcelle vous permet d'obtenir toutes les informations détaillées sur cette parcelle : DPE, transactions DVF, propriétaires, permis de construire, zones PLU, risques, et bien plus.

Vue d'ensemble

L'endpoint /api/v1/parcelles/{cadastre_id} retourne une fiche complète exhaustive d'une parcelle cadastrale avec plus de 30 catégories de données.

Fonctionnalités principales

✅ Informations cadastrales complètes
✅ Diagnostics de performance énergétique (DPE)
✅ Historique des transactions (DVF)
✅ Propriétaires et copropriétaires
✅ Occupants (entreprises)
✅ Permis de construire
✅ Zones PLU avec documents
✅ Monuments historiques
✅ Risques (argile, radon)
✅ Estimations de prix
✅ Géométries détaillées (centre, contour, bbox)

Obtenir une fiche parcelle basique

Par identifiant cadastral

cURL
JavaScript
PHP
Python

curl -X GET \
  "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

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

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

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

$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId";

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

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

print_r($parcelle);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

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

parcelle = response.json()
print(parcelle)

Réponse par défaut

Par défaut, l'API retourne les champs suivants :

cadastre_id - Identifiant cadastral
superficie - Superficie en m²
dpes - Diagnostics de performance énergétique
dvfs - Transactions immobilières
zones_plu - Zones PLU
centre - Point central (géométrie)

Personnaliser les champs retournés

Sélectionner des champs spécifiques

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,superficie,municipalite,detail,dpes,centre" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Demander uniquement les informations de base et les DPE
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,superficie,municipalite,detail,dpes,centre'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

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

$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,superficie,municipalite,detail,dpes,centre'
]);

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

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

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Demander uniquement les informations de base et les DPE
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={'champs': 'cadastre_id,superficie,municipalite,detail,dpes,centre'},
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

Tous les champs disponibles

cURL
JavaScript
PHP
Python

# Obtenir TOUS les champs disponibles
curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,section,numero,prefixe,superficie,perimetre,arpente,municipalite,quartier,lieu_dit,adresses,detail,batiments,zones_plu,dpes,dvfs,coproprietaires,proprietaires,occupants,permis_construire,risques,monuments_historiques,consommations,statistiques,centre,contour,bbox" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Obtenir TOUS les champs disponibles
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,section,numero,prefixe,superficie,perimetre,arpente,municipalite,quartier,lieu_dit,adresses,detail,batiments,zones_plu,dpes,dvfs,coproprietaires,proprietaires,occupants,permis_construire,risques,monuments_historiques,consommations,statistiques,centre,contour,bbox'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

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

// Obtenir TOUS les champs disponibles
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,section,numero,prefixe,superficie,perimetre,arpente,municipalite,quartier,lieu_dit,adresses,detail,batiments,zones_plu,dpes,dvfs,coproprietaires,proprietaires,occupants,permis_construire,risques,monuments_historiques,consommations,statistiques,centre,contour,bbox'
]);

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

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

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Obtenir TOUS les champs disponibles
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={
        'champs': 'cadastre_id,section,numero,prefixe,superficie,perimetre,arpente,municipalite,quartier,lieu_dit,adresses,detail,batiments,zones_plu,dpes,dvfs,coproprietaires,proprietaires,occupants,permis_construire,risques,monuments_historiques,consommations,statistiques,centre,contour,bbox'
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

Champs disponibles par catégorie

📍 Informations de base

cadastre_id - Identifiant cadastral (14 caractères)
section - Code de section
numero - Numéro de parcelle
prefixe - Préfixe
superficie - Superficie en m²
perimetre - Périmètre en m
arpente - Parcelle arpentée (boolean)

🗺️ Localisation

municipalite - Informations commune (code, nom, codes postaux)
quartier - Informations quartier IRIS
lieu_dit - Nom du lieu-dit
adresses - Adresses postales

🏠 Détails de la parcelle

detail - Détails complets :
- Piscines (nombre, surface, forme)
- Bâtiments durs et légers
- Surfaces (jardin, emprise au sol, habitable)
- Hauteurs (min, max)
- Altitudes (min, max)
- Construction (années, étages)
- Caractéristiques (type bâti, isolation, mitoyenneté)
- Risques (argile, radon)
- Estimations (prix vente, location)

🏗️ Bâtiments

batiments - Liste des bâtiments avec type, superficie, périmètre

📜 Urbanisme et réglementation

zones_plu - Zones PLU avec documents PDF
permis_construire - Permis de construire et autorisations

⚡ Performance énergétique

dpes - Diagnostics de performance énergétique complets
consommations - Consommations énergétiques (électricité, gaz)

💰 Transactions et estimations

dvfs - Ventes immobilières (DVF)
Estimations incluses dans detail

👥 Propriété et occupation

proprietaires - Propriétaires (SIREN, dénomination, forme juridique)
coproprietaires - Copropriétés
occupants - Entreprises occupantes (SIRET, activité, effectifs)

🏛️ Patrimoine et risques

monuments_historiques - Monuments historiques
risques - Risques naturels et technologiques

📊 Statistiques

statistiques - Statistiques diverses

🗺️ Géométries

centre - Point central (GeoJSON Point)
contour - Polygone complet (GeoJSON Polygon)
bbox - Boîte englobante (GeoJSON Polygon)

Obtenir les DPE d'une parcelle

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,dpes" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Récupérer uniquement les DPE
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?champs=cadastre_id,dpes`,
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

if (parcelle.dpes && parcelle.dpes.length > 0) {
  parcelle.dpes.forEach(dpe => {
    console.log(`DPE ${dpe.numero_dpe}:`);
    console.log(`  Étiquette énergie: ${dpe.etiquette_dpe}`);
    console.log(`  Étiquette GES: ${dpe.etiquette_ges}`);
    console.log(`  Consommation: ${dpe.conso_energie} kWh/m²/an`);
    console.log(`  Coût annuel: ${dpe.cout_total} €`);
  });
}

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

// Récupérer uniquement les DPE
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,dpes'
]);

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

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

if (!empty($parcelle['dpes'])) {
    foreach ($parcelle['dpes'] as $dpe) {
        echo "DPE {$dpe['numero_dpe']}:\n";
        echo "  Étiquette énergie: {$dpe['etiquette_dpe']}\n";
        echo "  Étiquette GES: {$dpe['etiquette_ges']}\n";
        echo "  Consommation: {$dpe['conso_energie']} kWh/m²/an\n";
        echo "  Coût annuel: {$dpe['cout_total']} €\n";
    }
}

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Récupérer uniquement les DPE
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={'champs': 'cadastre_id,dpes'},
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

if parcelle.get('dpes'):
    for dpe in parcelle['dpes']:
        print(f"DPE {dpe['numero_dpe']}:")
        print(f"  Étiquette énergie: {dpe['etiquette_dpe']}")
        print(f"  Étiquette GES: {dpe['etiquette_ges']}")
        print(f"  Consommation: {dpe['conso_energie']} kWh/m²/an")
        print(f"  Coût annuel: {dpe['cout_total']} €")

Exemple de DPE retourné :

{
  "dpes": [
    {
      "numero_dpe": "2301E0123456",
      "type_dpe": 0,
      "date_etablissement": "2023-03-15",
      "date_reception": "2023-03-20",
      "date_fin_validite": "2033-03-15",
      "etiquette_dpe": "D",
      "etiquette_ges": "C",
      "adresse": "8 Avenue des Champs-Élysées",
      "type_batiment": "maison",
      "bati_type": 3,
      "surface_habitable": 350,
      "annee_construction": 1900,
      "conso_energie": 220.5,
      "conso_chauffage": 180,
      "emission_ges": 45.2,
      "cout_total": 3200,
      "cout_chauffage": 2700
    }
  ]
}

Obtenir l'historique DVF

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,municipalite,dvfs" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Récupérer l'historique des transactions
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,municipalite,dvfs'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

if (parcelle.dvfs) {
  console.log(`Historique des transactions pour ${parcelle.cadastre_id}:`);
  parcelle.dvfs.forEach(dvf => {
    console.log(`  ${dvf.date_mutation}: ${dvf.valeur_fonciere.toLocaleString()} € - ${dvf.libelle_type}`);
  });
}

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

// Récupérer l'historique des transactions
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,municipalite,dvfs'
]);

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

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

if (!empty($parcelle['dvfs'])) {
    echo "Historique des transactions pour {$parcelle['cadastre_id']}:\n";
    foreach ($parcelle['dvfs'] as $dvf) {
        echo "  {$dvf['date_mutation']}: " . number_format($dvf['valeur_fonciere'], 0, ',', ' ') . " € - {$dvf['libelle_type']}\n";
    }
}

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Récupérer l'historique des transactions
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={'champs': 'cadastre_id,municipalite,dvfs'},
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

if parcelle.get('dvfs'):
    print(f"Historique des transactions pour {parcelle['cadastre_id']}:")
    for dvf in parcelle['dvfs']:
        print(f"  {dvf['date_mutation']}: {dvf['valeur_fonciere']:,.0f} € - {dvf['libelle_type']}")

Exemple de DVF retourné :

{
  "dvfs": [
    {
      "id_mutation": "2022-12345",
      "date_mutation": "2022-06-15",
      "nature_mutation": "Vente",
      "valeur_fonciere": 850000,
      "code_type_bien": 111,
      "libelle_type": "UNE MAISON",
      "bati_type": 3,
      "nb_lots": 1,
      "surface_terrain": 523.45,
      "surface_batie": 350
    }
  ]
}

Obtenir les zones PLU avec documents

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,zones_plu" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Récupérer les zones PLU et leurs documents
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?champs=cadastre_id,zones_plu`,
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

if (parcelle.zones_plu && parcelle.zones_plu.length > 0) {
  parcelle.zones_plu.forEach(zone => {
    console.log(`Zone ${zone.type_zone} (${zone.zone}):`);
    console.log(`  Titre: ${zone.titre}`);
    console.log(`  Surface: ${zone.surface} m²`);

    if (zone.documents && zone.documents.fichiers) {
      console.log(`  Documents:`);
      zone.documents.fichiers.forEach(doc => {
        console.log(`    - ${doc.titre} (${doc.categorie})`);
        console.log(`      URL: ${doc.url}`);
      });
    }
  });
}

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

// Récupérer les zones PLU et leurs documents
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,zones_plu'
]);

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

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

if (!empty($parcelle['zones_plu'])) {
    foreach ($parcelle['zones_plu'] as $zone) {
        echo "Zone {$zone['type_zone']} ({$zone['zone']}):\n";
        echo "  Titre: {$zone['titre']}\n";
        echo "  Surface: {$zone['surface']} m²\n";

        if (!empty($zone['documents']['fichiers'])) {
            echo "  Documents:\n";
            foreach ($zone['documents']['fichiers'] as $doc) {
                echo "    - {$doc['titre']} ({$doc['categorie']})\n";
                echo "      URL: {$doc['url']}\n";
            }
        }
    }
}

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Récupérer les zones PLU et leurs documents
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={'champs': 'cadastre_id,zones_plu'},
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

if parcelle.get('zones_plu'):
    for zone in parcelle['zones_plu']:
        print(f"Zone {zone['type_zone']} ({zone['zone']}):")
        print(f"  Titre: {zone['titre']}")
        print(f"  Surface: {zone['surface']} m²")

        if zone.get('documents', {}).get('fichiers'):
            print("  Documents:")
            for doc in zone['documents']['fichiers']:
                print(f"    - {doc['titre']} ({doc['categorie']})")
                print(f"      URL: {doc['url']}")

Exemple de zone PLU retournée :

{
  "zones_plu": [
    {
      "titre": "Zone Urbaine Mixte",
      "description": "Zone UB : Zone urbaine dense",
      "zone": "U",
      "type_zone": "UB",
      "surface": 523.45,
      "perimetre": 102.34,
      "documents": {
        "partition": "75108_PLU_20210115",
        "fichiers": [
          {
            "titre": "Règlement Zones UB",
            "nom_fichier": "75108_reglement_UB.pdf",
            "url": "https://example.com/plu/75108_reglement_UB.pdf",
            "categorie": "Documents Règlementaires",
            "date_creation": "2021-01-15"
          }
        ]
      }
    }
  ]
}

Obtenir les propriétaires

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,proprietaires,coproprietaires" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Récupérer les propriétaires d'une parcelle
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,proprietaires,coproprietaires'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

if (parcelle.proprietaires && parcelle.proprietaires.length > 0) {
  console.log('Propriétaires:');
  parcelle.proprietaires.forEach(proprio => {
    console.log(`  - ${proprio.denomination}`);
    console.log(`    SIREN: ${proprio.siren}`);
    console.log(`    Forme juridique: ${proprio.forme_juridique}`);
  });
}

if (parcelle.coproprietaires && parcelle.coproprietaires.length > 0) {
  console.log('\nCopropriétés:');
  parcelle.coproprietaires.forEach(copro => {
    console.log(`  - ${copro.nom}`);
    console.log(`    Immatriculation: ${copro.immatriculation}`);
    console.log(`    Nombre de lots: ${copro.nb_lot}`);
  });
}

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

// Récupérer les propriétaires d'une parcelle
$response = file_get_contents(
    "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
        'champs' => 'cadastre_id,proprietaires,coproprietaires'
    ]),
    false,
    stream_context_create([
        'http' => [
            'header' => "Authorization: Bearer $apiKey\r\n",
            'method' => 'GET'
        ]
    ])
);

$parcelle = json_decode($response, true);

if (!empty($parcelle['proprietaires'])) {
    echo "Propriétaires:\n";
    foreach ($parcelle['proprietaires'] as $proprio) {
        echo "  - {$proprio['denomination']}\n";
        echo "    SIREN: {$proprio['siren']}\n";
        echo "    Forme juridique: {$proprio['forme_juridique']}\n";
    }
}

if (!empty($parcelle['coproprietaires'])) {
    echo "\nCopropriétés:\n";
    foreach ($parcelle['coproprietaires'] as $copro) {
        echo "  - {$copro['nom']}\n";
        echo "    Immatriculation: {$copro['immatriculation']}\n";
        echo "    Nombre de lots: {$copro['nb_lot']}\n";
    }
}

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Récupérer les propriétaires d'une parcelle
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={'champs': 'cadastre_id,proprietaires,coproprietaires'},
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

if parcelle.get('proprietaires'):
    print("Propriétaires:")
    for proprio in parcelle['proprietaires']:
        print(f"  - {proprio['denomination']}")
        print(f"    SIREN: {proprio['siren']}")
        print(f"    Forme juridique: {proprio['forme_juridique']}")

if parcelle.get('coproprietaires'):
    print("\nCopropriétés:")
    for copro in parcelle['coproprietaires']:
        print(f"  - {copro['nom']}")
        print(f"    Immatriculation: {copro['immatriculation']}")
        print(f"    Nombre de lots: {copro['nb_lot']}")

Obtenir les géométries complètes

Contour complet de la parcelle

cURL
JavaScript
PHP
Python

curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?champs=cadastre_id,superficie,contour&geometrie=contour" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Récupérer le contour complet (polygone) de la parcelle
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    champs: 'cadastre_id,superficie,contour',
    geometrie: 'contour'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

const parcelle = await response.json();

// Le contour est un polygone GeoJSON
console.log('Type:', parcelle.contour.type); // "Polygon"
console.log('Coordonnées:', parcelle.contour.coordinates);

// Afficher sur une carte Leaflet/Mapbox
// L.geoJSON(parcelle.contour).addTo(map);

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

// Récupérer le contour complet (polygone) de la parcelle
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'champs' => 'cadastre_id,superficie,contour',
    'geometrie' => 'contour'
]);

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

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

// Le contour est un polygone GeoJSON
echo "Type: " . $parcelle['contour']['type'] . "\n"; // "Polygon"
echo "Coordonnées: " . json_encode($parcelle['contour']['coordinates']) . "\n";

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Récupérer le contour complet (polygone) de la parcelle
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={
        'champs': 'cadastre_id,superficie,contour',
        'geometrie': 'contour'
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

parcelle = response.json()

# Le contour est un polygone GeoJSON
print('Type:', parcelle['contour']['type'])  # "Polygon"
print('Coordonnées:', parcelle['contour']['coordinates'])

# Afficher sur une carte avec folium
# import folium
# m = folium.Map()
# folium.GeoJson(parcelle['contour']).add_to(m)

Format GeoJSON

cURL
JavaScript
PHP
Python

# Obtenir la parcelle au format GeoJSON
curl "https://app.infoparcelle.fr/api/v1/parcelles/75108000BO0025?format=geojson&geometrie=contour" \
  -H "Authorization: Bearer VOTRE_CLE_API"

const apiKey = process.env.INFOPARCELLE_API_KEY;
const cadastreId = '75108000BO0025';

// Obtenir la parcelle au format GeoJSON
const response = await fetch(
  `https://app.infoparcelle.fr/api/v1/parcelles/${cadastreId}?` +
  new URLSearchParams({
    format: 'geojson',
    geometrie: 'contour'
  }),
  {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  }
);

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

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

// Obtenir la parcelle au format GeoJSON
$url = "https://app.infoparcelle.fr/api/v1/parcelles/$cadastreId?" . http_build_query([
    'format' => 'geojson',
    'geometrie' => 'contour'
]);

$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);

print_r($geojson);

import os
import requests

api_key = os.getenv('INFOPARCELLE_API_KEY')
cadastre_id = '75108000BO0025'

# Obtenir la parcelle au format GeoJSON
response = requests.get(
    f'https://app.infoparcelle.fr/api/v1/parcelles/{cadastre_id}',
    params={
        'format': 'geojson',
        'geometrie': 'contour'
    },
    headers={'Authorization': f'Bearer {api_key}'}
)

geojson = response.json()
print(geojson)

Réponse GeoJSON :

{
  "type": "Feature",
  "geometry": {
    "type": "Polygon",
    "coordinates": [[[2.32, 48.85], [2.37, 48.85], [2.37, 48.87], [2.32, 48.87], [2.32, 48.85]]]
  },
  "properties": {
    "cadastre_id": "75108000BO0025",
    "superficie": 523.45,
    "dpes": [...],
    "dvfs": [...]
  }
}

Cas d'usage avancés

1. Analyse complète d'une parcelle

JavaScript
PHP
Python

async function analyserParcelleComplete(cadastreId) {
  /**
   * Analyse complète d'une parcelle avec score de qualité
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

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

  const parcelle = await response.json();

  // Calculer un score de qualité
  const score = {
    performance_energetique: 0,
    valeur_marche: 0,
    risques: 0,
    urbanisme: 0,
    score_global: 0
  };

  // 1. Performance énergétique (0-10)
  if (parcelle.dpes && parcelle.dpes.length > 0) {
    const dpe = parcelle.dpes[0];
    const etiquettes = { A: 10, B: 8, C: 6, D: 5, E: 4, F: 2, G: 0 };
    score.performance_energetique = etiquettes[dpe.etiquette_dpe] || 0;
  }

  // 2. Valeur marché (0-10)
  if (parcelle.dvfs && parcelle.dvfs.length > 0) {
    const dvf = parcelle.dvfs[0];
    const dateMutation = new Date(dvf.date_mutation);
    const ancienneteMois = (Date.now() - dateMutation) / (1000 * 60 * 60 * 24 * 30);

    if (ancienneteMois < 12) {
      score.valeur_marche = 10;
    } else if (ancienneteMois < 24) {
      score.valeur_marche = 7;
    } else {
      score.valeur_marche = 5;
    }
  }

  // 3. Risques (0-10)
  if (parcelle.detail?.risques) {
    const risques = parcelle.detail.risques;
    let scoreRisque = 10;
    if (risques.argile === 'Fort') scoreRisque -= 3;
    else if (risques.argile === 'Moyen') scoreRisque -= 1;
    if (risques.radon === 'Fort') scoreRisque -= 3;
    else if (risques.radon === 'Moyen') scoreRisque -= 1;
    score.risques = Math.max(0, scoreRisque);
  } else {
    score.risques = 10;
  }

  // 4. Urbanisme (0-10)
  if (parcelle.zones_plu && parcelle.zones_plu.length > 0) {
    const zone = parcelle.zones_plu[0].zone;
    const zonesScores = { U: 10, AU: 7, A: 4, N: 6 };
    score.urbanisme = zonesScores[zone] || 5;
  }

  // Score global (moyenne)
  const scoresValides = Object.values(score).filter(v => v > 0 && typeof v === 'number');
  score.score_global = scoresValides.reduce((a, b) => a + b, 0) / scoresValides.length || 0;

  return {
    cadastre_id: cadastreId,
    adresse: parcelle.municipalite?.nom,
    superficie: parcelle.superficie,
    scores: score,
    details: {
      dpe: parcelle.dpes?.[0]?.etiquette_dpe || null,
      derniere_vente: parcelle.dvfs?.[0]?.date_mutation || null,
      zone_plu: parcelle.zones_plu?.[0]?.type_zone || null
    }
  };
}

// Utilisation
const analyse = await analyserParcelleComplete('75108000BO0025');
console.log(`Analyse parcelle ${analyse.cadastre_id}:`);
console.log(`  Score global: ${analyse.scores.score_global.toFixed(1)}/10`);
console.log(`  Performance énergétique: ${analyse.scores.performance_energetique}/10`);
console.log(`  Valeur marché: ${analyse.scores.valeur_marche}/10`);
console.log(`  Risques: ${analyse.scores.risques}/10`);
console.log(`  Urbanisme: ${analyse.scores.urbanisme}/10`);

<?php
function analyser_parcelle_complete($cadastre_id, $api_key) {
    /**
     * Analyse complète d'une parcelle avec score de qualité
     */
    $params = http_build_query([
        'champs' => 'cadastre_id,superficie,municipalite,detail,dpes,dvfs,zones_plu,risques'
    ]);

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

    $parcelle = json_decode($response, true);

    // Calculer un score de qualité
    $score = [
        'performance_energetique' => 0,
        'valeur_marche' => 0,
        'risques' => 0,
        'urbanisme' => 0,
        'score_global' => 0
    ];

    // 1. Performance énergétique (0-10)
    if (!empty($parcelle['dpes'])) {
        $dpe = $parcelle['dpes'][0];
        $etiquettes = ['A' => 10, 'B' => 8, 'C' => 6, 'D' => 5, 'E' => 4, 'F' => 2, 'G' => 0];
        $score['performance_energetique'] = $etiquettes[$dpe['etiquette_dpe']] ?? 0;
    }

    // 2. Valeur marché (0-10)
    if (!empty($parcelle['dvfs'])) {
        $dvf = $parcelle['dvfs'][0];
        $date_mutation = new DateTime($dvf['date_mutation']);
        $anciennete_mois = (new DateTime())->diff($date_mutation)->days / 30;

        if ($anciennete_mois < 12) {
            $score['valeur_marche'] = 10;
        } elseif ($anciennete_mois < 24) {
            $score['valeur_marche'] = 7;
        } else {
            $score['valeur_marche'] = 5;
        }
    }

    // 3. Risques (0-10)
    if (!empty($parcelle['detail']['risques'])) {
        $risques = $parcelle['detail']['risques'];
        $score_risque = 10;
        if (($risques['argile'] ?? '') === 'Fort') $score_risque -= 3;
        elseif (($risques['argile'] ?? '') === 'Moyen') $score_risque -= 1;
        if (($risques['radon'] ?? '') === 'Fort') $score_risque -= 3;
        elseif (($risques['radon'] ?? '') === 'Moyen') $score_risque -= 1;
        $score['risques'] = max(0, $score_risque);
    } else {
        $score['risques'] = 10;
    }

    // 4. Urbanisme (0-10)
    if (!empty($parcelle['zones_plu'])) {
        $zone = $parcelle['zones_plu'][0]['zone'];
        $zones_scores = ['U' => 10, 'AU' => 7, 'A' => 4, 'N' => 6];
        $score['urbanisme'] = $zones_scores[$zone] ?? 5;
    }

    // Score global (moyenne)
    $scores_valides = array_filter($score, fn($v) => $v > 0 && is_numeric($v));
    $score['score_global'] = count($scores_valides) > 0 ?
        array_sum($scores_valides) / count($scores_valides) : 0;

    return [
        'cadastre_id' => $cadastre_id,
        'adresse' => $parcelle['municipalite']['nom'] ?? null,
        'superficie' => $parcelle['superficie'] ?? null,
        'scores' => $score,
        'details' => [
            'dpe' => $parcelle['dpes'][0]['etiquette_dpe'] ?? null,
            'derniere_vente' => $parcelle['dvfs'][0]['date_mutation'] ?? null,
            'zone_plu' => $parcelle['zones_plu'][0]['type_zone'] ?? null
        ]
    ];
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$analyse = analyser_parcelle_complete('75108000BO0025', $api_key);
echo "Analyse parcelle {$analyse['cadastre_id']}:\n";
echo "  Score global: " . round($analyse['scores']['score_global'], 1) . "/10\n";
echo "  Performance énergétique: {$analyse['scores']['performance_energetique']}/10\n";
echo "  Valeur marché: {$analyse['scores']['valeur_marche']}/10\n";
echo "  Risques: {$analyse['scores']['risques']}/10\n";
echo "  Urbanisme: {$analyse['scores']['urbanisme']}/10\n";
?>

import os
import requests
from datetime import datetime

def analyser_parcelle_complete(cadastre_id):
    """
    Analyse complète d'une parcelle avec score de qualité
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

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

    parcelle = response.json()

    # Calculer un score de qualité
    score = {
        'performance_energetique': 0,
        'valeur_marche': 0,
        'risques': 0,
        'urbanisme': 0,
        'score_global': 0
    }

    # 1. Performance énergétique (0-10)
    if parcelle.get('dpes') and len(parcelle['dpes']) > 0:
        dpe = parcelle['dpes'][0]
        etiquettes = {'A': 10, 'B': 8, 'C': 6, 'D': 5, 'E': 4, 'F': 2, 'G': 0}
        score['performance_energetique'] = etiquettes.get(dpe.get('etiquette_dpe'), 0)

    # 2. Valeur marché (0-10)
    if parcelle.get('dvfs') and len(parcelle['dvfs']) > 0:
        dvf = parcelle['dvfs'][0]
        # Vente récente = bonne liquidité
        date_mutation = datetime.strptime(dvf['date_mutation'], '%Y-%m-%d')
        anciennete_mois = (datetime.now() - date_mutation).days / 30
        if anciennete_mois < 12:
            score['valeur_marche'] = 10
        elif anciennete_mois < 24:
            score['valeur_marche'] = 7
        else:
            score['valeur_marche'] = 5

    # 3. Risques (0-10)
    if parcelle.get('detail', {}).get('risques'):
        risques = parcelle['detail']['risques']
        score_risque = 10
        if risques.get('argile') == 'Fort':
            score_risque -= 3
        elif risques.get('argile') == 'Moyen':
            score_risque -= 1
        if risques.get('radon') == 'Fort':
            score_risque -= 3
        elif risques.get('radon') == 'Moyen':
            score_risque -= 1
        score['risques'] = max(0, score_risque)
    else:
        score['risques'] = 10  # Pas de risques connus

    # 4. Urbanisme (0-10)
    if parcelle.get('zones_plu') and len(parcelle['zones_plu']) > 0:
        zone = parcelle['zones_plu'][0]['zone']
        zones_scores = {'U': 10, 'AU': 7, 'A': 4, 'N': 6}
        score['urbanisme'] = zones_scores.get(zone, 5)

    # Score global (moyenne)
    scores_valides = [v for v in score.values() if v > 0 and isinstance(v, (int, float))]
    score['score_global'] = sum(scores_valides) / len(scores_valides) if scores_valides else 0

    return {
        'cadastre_id': cadastre_id,
        'adresse': parcelle.get('municipalite', {}).get('nom'),
        'superficie': parcelle.get('superficie'),
        'scores': score,
        'details': {
            'dpe': parcelle.get('dpes', [{}])[0].get('etiquette_dpe') if parcelle.get('dpes') else None,
            'derniere_vente': parcelle.get('dvfs', [{}])[0].get('date_mutation') if parcelle.get('dvfs') else None,
            'zone_plu': parcelle.get('zones_plu', [{}])[0].get('type_zone') if parcelle.get('zones_plu') else None,
        }
    }

# Utilisation
analyse = analyser_parcelle_complete('75108000BO0025')
print(f"Analyse parcelle {analyse['cadastre_id']}:")
print(f"  Score global: {analyse['scores']['score_global']:.1f}/10")
print(f"  Performance énergétique: {analyse['scores']['performance_energetique']}/10")
print(f"  Valeur marché: {analyse['scores']['valeur_marche']}/10")
print(f"  Risques: {analyse['scores']['risques']}/10")
print(f"  Urbanisme: {analyse['scores']['urbanisme']}/10")

2. Comparaison de parcelles

JavaScript
PHP
Python

// Comparer plusieurs parcelles
async function comparerParcelles(cadastreIds) {
  const apiKey = process.env.INFOPARCELLE_API_KEY;

  const parcelles = await Promise.all(
    cadastreIds.map(async (id) => {
      const response = await fetch(
        `https://app.infoparcelle.fr/api/v1/parcelles/${id}?` +
        new URLSearchParams({
          champs: 'cadastre_id,superficie,detail,dpes,dvfs'
        }),
        {
          headers: { 'Authorization': `Bearer ${apiKey}` }
        }
      );
      return await response.json();
    })
  );

  // Créer un tableau comparatif
  const comparaison = parcelles.map(p => {
    const dpe = p.dpes?.[0];
    const dvf = p.dvfs?.[0];
    const estimation = p.detail?.estimations;

    return {
      cadastre_id: p.cadastre_id,
      superficie: p.superficie,
      dpe_energie: dpe?.etiquette_dpe || 'N/A',
      dpe_ges: dpe?.etiquette_ges || 'N/A',
      derniere_vente: dvf?.valeur_fonciere || null,
      estimation_prix: estimation?.prix_vente || null,
      prix_m2: estimation?.prix_vente_ppm || null,
    };
  });

  return comparaison;
}

// Utilisation
const parcelles = await comparerParcelles([
  '75108000BO0025',
  '75108000BO0026',
  '75108000BO0027'
]);

console.table(parcelles);

<?php
function comparer_parcelles($cadastre_ids, $api_key) {
    // Comparer plusieurs parcelles
    $parcelles = [];

    foreach ($cadastre_ids as $id) {
        $params = http_build_query([
            'champs' => 'cadastre_id,superficie,detail,dpes,dvfs'
        ]);

        $ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/$id?$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);
    }

    // Créer un tableau comparatif
    $comparaison = array_map(function($p) {
        $dpe = $p['dpes'][0] ?? null;
        $dvf = $p['dvfs'][0] ?? null;
        $estimation = $p['detail']['estimations'] ?? null;

        return [
            'cadastre_id' => $p['cadastre_id'],
            'superficie' => $p['superficie'],
            'dpe_energie' => $dpe['etiquette_dpe'] ?? 'N/A',
            'dpe_ges' => $dpe['etiquette_ges'] ?? 'N/A',
            'derniere_vente' => $dvf['valeur_fonciere'] ?? null,
            'estimation_prix' => $estimation['prix_vente'] ?? null,
            'prix_m2' => $estimation['prix_vente_ppm'] ?? null
        ];
    }, $parcelles);

    return $comparaison;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$parcelles = comparer_parcelles([
    '75108000BO0025',
    '75108000BO0026',
    '75108000BO0027'
], $api_key);

print_r($parcelles);
?>

import os
import requests

def comparer_parcelles(cadastre_ids):
    """
    Comparer plusieurs parcelles
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')
    parcelles = []

    for id in cadastre_ids:
        response = requests.get(
            f'https://app.infoparcelle.fr/api/v1/parcelles/{id}',
            params={'champs': 'cadastre_id,superficie,detail,dpes,dvfs'},
            headers={'Authorization': f'Bearer {api_key}'}
        )
        parcelles.append(response.json())

    # Créer un tableau comparatif
    comparaison = []
    for p in parcelles:
        dpe = p.get('dpes', [{}])[0]
        dvf = p.get('dvfs', [{}])[0]
        estimation = p.get('detail', {}).get('estimations', {})

        comparaison.append({
            'cadastre_id': p['cadastre_id'],
            'superficie': p['superficie'],
            'dpe_energie': dpe.get('etiquette_dpe', 'N/A'),
            'dpe_ges': dpe.get('etiquette_ges', 'N/A'),
            'derniere_vente': dvf.get('valeur_fonciere'),
            'estimation_prix': estimation.get('prix_vente'),
            'prix_m2': estimation.get('prix_vente_ppm')
        })

    return comparaison

# Utilisation
parcelles = comparer_parcelles([
    '75108000BO0025',
    '75108000BO0026',
    '75108000BO0027'
])

for p in parcelles:
    print(p)

3. Export PDF détaillé

JavaScript
PHP
Python

async function genererRapportParcelle(cadastreId) {
  /**
   * Génère un rapport détaillé d'une parcelle
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

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

  const parcelle = await response.json();

  let rapport = `
====================================
RAPPORT PARCELLE - ${parcelle.cadastre_id}
====================================

INFORMATIONS GÉNÉRALES
----------------------
Commune: ${parcelle.municipalite?.nom || 'N/A'}
Superficie: ${parcelle.superficie} m²
Section: ${parcelle.section}

PERFORMANCE ÉNERGÉTIQUE
-----------------------
`;

  if (parcelle.dpes && parcelle.dpes.length > 0) {
    const dpe = parcelle.dpes[0];
    rapport += `
Étiquette énergie: ${dpe.etiquette_dpe}
Étiquette GES: ${dpe.etiquette_ges}
Consommation: ${dpe.conso_energie} kWh/m²/an
Coût annuel: ${dpe.cout_total} €
Date de validité: ${dpe.date_fin_validite}
`;
  } else {
    rapport += "Aucun DPE disponible\n";
  }

  rapport += `
HISTORIQUE DES TRANSACTIONS
----------------------------
`;

  if (parcelle.dvfs && parcelle.dvfs.length > 0) {
    // 5 dernières ventes
    parcelle.dvfs.slice(0, 5).forEach(dvf => {
      rapport += `${dvf.date_mutation}: ${dvf.valeur_fonciere.toLocaleString()} € - ${dvf.libelle_type}\n`;
    });
  } else {
    rapport += "Aucune transaction enregistrée\n";
  }

  rapport += `
URBANISME
---------
`;

  if (parcelle.zones_plu && parcelle.zones_plu.length > 0) {
    const zone = parcelle.zones_plu[0];
    rapport += `
Zone: ${zone.type_zone} (${zone.zone})
Description: ${zone.description}
`;
  }

  return rapport;
}

// Utilisation
const rapport = await genererRapportParcelle('75108000BO0025');
console.log(rapport);

// Sauvegarder dans un fichier (Node.js)
const fs = require('fs');
fs.writeFileSync('rapport_parcelle.txt', rapport, 'utf-8');

<?php
function generer_rapport_parcelle($cadastre_id, $api_key) {
    /**
     * Génère un rapport détaillé d'une parcelle
     */
    $ch = curl_init("https://app.infoparcelle.fr/api/v1/parcelles/$cadastre_id");
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $api_key"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $parcelle = json_decode($response, true);

    $rapport = "
====================================
RAPPORT PARCELLE - {$parcelle['cadastre_id']}
====================================

INFORMATIONS GÉNÉRALES
----------------------
Commune: " . ($parcelle['municipalite']['nom'] ?? 'N/A') . "
Superficie: {$parcelle['superficie']} m²
Section: {$parcelle['section']}

PERFORMANCE ÉNERGÉTIQUE
-----------------------
";

    if (!empty($parcelle['dpes'])) {
        $dpe = $parcelle['dpes'][0];
        $rapport .= "
Étiquette énergie: {$dpe['etiquette_dpe']}
Étiquette GES: {$dpe['etiquette_ges']}
Consommation: {$dpe['conso_energie']} kWh/m²/an
Coût annuel: {$dpe['cout_total']} €
Date de validité: {$dpe['date_fin_validite']}
";
    } else {
        $rapport .= "Aucun DPE disponible\n";
    }

    $rapport .= "
HISTORIQUE DES TRANSACTIONS
----------------------------
";

    if (!empty($parcelle['dvfs'])) {
        // 5 dernières ventes
        foreach (array_slice($parcelle['dvfs'], 0, 5) as $dvf) {
            $valeur = number_format($dvf['valeur_fonciere'], 0, ',', ' ');
            $rapport .= "{$dvf['date_mutation']}: $valeur € - {$dvf['libelle_type']}\n";
        }
    } else {
        $rapport .= "Aucune transaction enregistrée\n";
    }

    $rapport .= "
URBANISME
---------
";

    if (!empty($parcelle['zones_plu'])) {
        $zone = $parcelle['zones_plu'][0];
        $rapport .= "
Zone: {$zone['type_zone']} ({$zone['zone']})
Description: {$zone['description']}
";
    }

    return $rapport;
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$rapport = generer_rapport_parcelle('75108000BO0025', $api_key);
echo $rapport;

// Sauvegarder dans un fichier
file_put_contents('rapport_parcelle.txt', $rapport);
?>

import os
import requests

def generer_rapport_parcelle(cadastre_id):
    """
    Génère un rapport détaillé d'une parcelle
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

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

    parcelle = response.json()

    rapport = f"""
====================================
RAPPORT PARCELLE - {parcelle['cadastre_id']}
====================================

INFORMATIONS GÉNÉRALES
----------------------
Commune: {parcelle.get('municipalite', {}).get('nom')}
Superficie: {parcelle.get('superficie')} m²
Section: {parcelle.get('section')}

PERFORMANCE ÉNERGÉTIQUE
-----------------------
"""

    if parcelle.get('dpes'):
        dpe = parcelle['dpes'][0]
        rapport += f"""
Étiquette énergie: {dpe.get('etiquette_dpe')}
Étiquette GES: {dpe.get('etiquette_ges')}
Consommation: {dpe.get('conso_energie')} kWh/m²/an
Coût annuel: {dpe.get('cout_total')} €
Date de validité: {dpe.get('date_fin_validite')}
        """
    else:
        rapport += "    Aucun DPE disponible\n"

    rapport += """
HISTORIQUE DES TRANSACTIONS
----------------------------
"""

    if parcelle.get('dvfs'):
        for dvf in parcelle['dvfs'][:5]:  # 5 dernières ventes
            rapport += f"""
{dvf['date_mutation']}: {dvf['valeur_fonciere']:,.0f} € - {dvf['libelle_type']}
            """
    else:
        rapport += "    Aucune transaction enregistrée\n"

    rapport += """
URBANISME
---------
"""

    if parcelle.get('zones_plu'):
        zone = parcelle['zones_plu'][0]
        rapport += f"""
Zone: {zone.get('type_zone')} ({zone.get('zone')})
Description: {zone.get('description')}
        """

    return rapport

# Utilisation
rapport = generer_rapport_parcelle('75108000BO0025')
print(rapport)

# Sauvegarder dans un fichier
with open('rapport_parcelle.txt', 'w', encoding='utf-8') as f:
    f.write(rapport)

4. Détection d'opportunités d'investissement

JavaScript
PHP
Python

async function detecterOpportunite(cadastreId) {
  /**
   * Détecter les opportunités d'investissement
   */
  const apiKey = process.env.INFOPARCELLE_API_KEY;

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

  const parcelle = await response.json();
  const opportunites = [];

  // 1. Opportunité rénovation énergétique
  const dpe = parcelle.dpes?.[0];
  if (dpe && ['F', 'G'].includes(dpe.etiquette_dpe)) {
    const economie = dpe.cout_total * 0.6; // Économie estimée après rénovation
    opportunites.push({
      type: 'Rénovation énergétique',
      potentiel: 'ÉLEVÉ',
      description: `Passoire thermique ${dpe.etiquette_dpe}`,
      gain_estime: `${Math.round(economie)} €/an`,
      actions: [
        'Isolation des combles',
        'Changement de chauffage',
        'Isolation des murs'
      ]
    });
  }

  // 2. Opportunité division parcellaire
  const superficie = parcelle.superficie;
  const zonePlu = parcelle.zones_plu?.[0]?.zone;
  if (superficie > 1000 && zonePlu === 'U') {
    opportunites.push({
      type: 'Division parcellaire',
      potentiel: 'MOYEN',
      description: `Grande parcelle de ${superficie} m² en zone urbaine`,
      gain_estime: 'Potentiel de valorisation importante',
      actions: [
        'Étude de faisabilité',
        'Demande de certificat d\'urbanisme',
        'Division cadastrale'
      ]
    });
  }

  // 3. Opportunité construction/extension
  const permis = parcelle.permis_construire || [];
  const permisRecents = permis.filter(p => {
    const date = new Date(p.date_autorisation);
    return (new Date() - date) / (1000 * 60 * 60 * 24) < 365 * 2;
  });

  if (permisRecents.length === 0 && zonePlu === 'U') {
    opportunites.push({
      type: 'Potentiel de construction',
      potentiel: 'MOYEN',
      description: 'Aucun permis récent, potentiel d\'extension',
      gain_estime: 'À évaluer selon PLU',
      actions: [
        'Consulter le PLU local',
        'Estimer le potentiel constructible',
        'Consultation architecte'
      ]
    });
  }

  return {
    cadastre_id: cadastreId,
    total_opportunites: opportunites.length,
    opportunites
  };
}

// Utilisation
const resultat = await detecterOpportunite('75108000BO0025');
console.log(`Opportunités détectées: ${resultat.total_opportunites}`);
resultat.opportunites.forEach((opp, i) => {
  console.log(`\n${i + 1}. ${opp.type} - Potentiel: ${opp.potentiel}`);
  console.log(`   ${opp.description}`);
  console.log(`   Gain estimé: ${opp.gain_estime}`);
});

<?php
function detecter_opportunite($cadastre_id, $api_key) {
    /**
     * Détecter les opportunités d'investissement
     */
    $params = http_build_query([
        'champs' => 'cadastre_id,superficie,detail,dpes,dvfs,zones_plu,permis_construire'
    ]);

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

    $parcelle = json_decode($response, true);
    $opportunites = [];

    // 1. Opportunité rénovation énergétique
    if (!empty($parcelle['dpes'])) {
        $dpe = $parcelle['dpes'][0];
        if (in_array($dpe['etiquette_dpe'], ['F', 'G'])) {
            $economie = $dpe['cout_total'] * 0.6; // Économie estimée après rénovation
            $opportunites[] = [
                'type' => 'Rénovation énergétique',
                'potentiel' => 'ÉLEVÉ',
                'description' => "Passoire thermique {$dpe['etiquette_dpe']}",
                'gain_estime' => round($economie) . ' €/an',
                'actions' => [
                    'Isolation des combles',
                    'Changement de chauffage',
                    'Isolation des murs'
                ]
            ];
        }
    }

    // 2. Opportunité division parcellaire
    $superficie = $parcelle['superficie'];
    $zone_plu = $parcelle['zones_plu'][0]['zone'] ?? null;
    if ($superficie > 1000 && $zone_plu === 'U') {
        $opportunites[] = [
            'type' => 'Division parcellaire',
            'potentiel' => 'MOYEN',
            'description' => "Grande parcelle de $superficie m² en zone urbaine",
            'gain_estime' => 'Potentiel de valorisation importante',
            'actions' => [
                'Étude de faisabilité',
                'Demande de certificat d\'urbanisme',
                'Division cadastrale'
            ]
        ];
    }

    // 3. Opportunité construction/extension
    $permis = $parcelle['permis_construire'] ?? [];
    $permis_recents = array_filter($permis, function($p) {
        $date = new DateTime($p['date_autorisation']);
        $diff = (new DateTime())->diff($date)->days;
        return $diff < 365 * 2;
    });

    if (count($permis_recents) === 0 && $zone_plu === 'U') {
        $opportunites[] = [
            'type' => 'Potentiel de construction',
            'potentiel' => 'MOYEN',
            'description' => 'Aucun permis récent, potentiel d\'extension',
            'gain_estime' => 'À évaluer selon PLU',
            'actions' => [
                'Consulter le PLU local',
                'Estimer le potentiel constructible',
                'Consultation architecte'
            ]
        ];
    }

    return [
        'cadastre_id' => $cadastre_id,
        'total_opportunites' => count($opportunites),
        'opportunites' => $opportunites
    ];
}

// Utilisation
$api_key = getenv('INFOPARCELLE_API_KEY');
$resultat = detecter_opportunite('75108000BO0025', $api_key);
echo "Opportunités détectées: {$resultat['total_opportunites']}\n";
foreach ($resultat['opportunites'] as $i => $opp) {
    echo "\n" . ($i + 1) . ". {$opp['type']} - Potentiel: {$opp['potentiel']}\n";
    echo "   {$opp['description']}\n";
    echo "   Gain estimé: {$opp['gain_estime']}\n";
}
?>

import os
import requests
from datetime import datetime, timedelta

def detecter_opportunite(cadastre_id):
    """
    Détecter les opportunités d'investissement
    """
    api_key = os.getenv('INFOPARCELLE_API_KEY')

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

    parcelle = response.json()
    opportunites = []

    # 1. Opportunité rénovation énergétique
    dpe = parcelle.get('dpes', [{}])[0] if parcelle.get('dpes') else {}
    if dpe.get('etiquette_dpe') in ['F', 'G']:
        economie = dpe.get('cout_total', 0) * 0.6  # Économie estimée après rénovation
        opportunites.append({
            'type': 'Rénovation énergétique',
            'potentiel': 'ÉLEVÉ',
            'description': f"Passoire thermique {dpe['etiquette_dpe']}",
            'gain_estime': f"{round(economie)} €/an",
            'actions': [
                'Isolation des combles',
                'Changement de chauffage',
                'Isolation des murs'
            ]
        })

    # 2. Opportunité division parcellaire
    superficie = parcelle.get('superficie', 0)
    zone_plu = parcelle.get('zones_plu', [{}])[0].get('zone') if parcelle.get('zones_plu') else None
    if superficie > 1000 and zone_plu == 'U':
        opportunites.append({
            'type': 'Division parcellaire',
            'potentiel': 'MOYEN',
            'description': f"Grande parcelle de {superficie} m² en zone urbaine",
            'gain_estime': 'Potentiel de valorisation importante',
            'actions': [
                'Étude de faisabilité',
                'Demande de certificat d\'urbanisme',
                'Division cadastrale'
            ]
        })

    # 3. Opportunité construction/extension
    permis = parcelle.get('permis_construire', [])
    permis_recents = [
        p for p in permis
        if (datetime.now() - datetime.strptime(p.get('date_autorisation', '1900-01-01'), '%Y-%m-%d')).days < 365 * 2
    ]

    if len(permis_recents) == 0 and zone_plu == 'U':
        opportunites.append({
            'type': 'Potentiel de construction',
            'potentiel': 'MOYEN',
            'description': 'Aucun permis récent, potentiel d\'extension',
            'gain_estime': 'À évaluer selon PLU',
            'actions': [
                'Consulter le PLU local',
                'Estimer le potentiel constructible',
                'Consultation architecte'
            ]
        })

    return {
        'cadastre_id': cadastre_id,
        'total_opportunites': len(opportunites),
        'opportunites': opportunites
    }

# Utilisation
resultat = detecter_opportunite('75108000BO0025')
print(f"Opportunités détectées: {resultat['total_opportunites']}")
for i, opp in enumerate(resultat['opportunites'], 1):
    print(f"\n{i}. {opp['type']} - Potentiel: {opp['potentiel']}")
    print(f"   {opp['description']}")
    print(f"   Gain estimé: {opp['gain_estime']}")

Bonnes pratiques

✅ À faire

Demander uniquement les champs nécessaires avec le paramètre champs
Cacher les résultats pour les parcelles fréquemment consultées
Vérifier la validité des DPE (date de fin de validité)
Utiliser le format GeoJSON pour l'affichage cartographique
Gérer les champs null (toutes les parcelles n'ont pas toutes les données)
Vérifier la date des transactions DVF pour la pertinence

❌ À éviter

❌ Demander tous les champs si vous n'en avez pas besoin
❌ Ignorer les dates de validité des DPE (valides 10 ans)
❌ Ne pas gérer les cas où certains champs sont absents
❌ Multiplier les requêtes inutiles
❌ Ne pas vérifier l'existence des données avant de les utiliser

Structure complète de la réponse

{
  "cadastre_id": "75108000BO0025",
  "section": "BO",
  "numero": "0025",
  "superficie": 523.45,
  "perimetre": 102.34,
  "municipalite": {
    "code": "75108",
    "nom": "Paris 8e Arrondissement",
    "codes_postaux": ["75008"]
  },
  "detail": {
    "surfaces": {
      "jardin": 100,
      "emprise_sol": 200.5,
      "habitable": 350
    },
    "construction": {
      "annee_min": 1890,
      "annee_max": 1920,
      "nombre_etages": 3
    },
    "estimations": {
      "prix_vente": 850000,
      "prix_vente_ppm": 2428.57
    }
  },
  "dpes": [...],
  "dvfs": [...],
  "zones_plu": [...],
  "proprietaires": [...],
  "centre": {
    "type": "Point",
    "coordinates": [2.3522, 48.8566]
  }
}

Performances

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

Voir aussi

Rechercher des parcelles - Recherche multicritère
Référence API - Documentation technique complète de l'API
Transactions DVF - Rechercher les ventes
Performance énergétique - Rechercher les DPE

Conseil pratique

Utilisez d'abord la recherche de parcelles pour trouver des parcelles intéressantes, puis récupérez la fiche complète uniquement pour celles qui vous intéressent !

Vue d'ensemble​

Fonctionnalités principales​

Obtenir une fiche parcelle basique​

Par identifiant cadastral​

Réponse par défaut​

Personnaliser les champs retournés​

Sélectionner des champs spécifiques​

Tous les champs disponibles​

Champs disponibles par catégorie​

📍 Informations de base​

🗺️ Localisation​

🏠 Détails de la parcelle​

🏗️ Bâtiments​

📜 Urbanisme et réglementation​

⚡ Performance énergétique​

💰 Transactions et estimations​

👥 Propriété et occupation​

🏛️ Patrimoine et risques​

📊 Statistiques​

🗺️ Géométries​

Obtenir les DPE d'une parcelle​

Obtenir l'historique DVF​

Obtenir les zones PLU avec documents​

Obtenir les propriétaires​

Obtenir les géométries complètes​

Contour complet de la parcelle​

Format GeoJSON​

Cas d'usage avancés​

1. Analyse complète d'une parcelle​

2. Comparaison de parcelles​

3. Export PDF détaillé​

4. Détection d'opportunités d'investissement​

Bonnes pratiques​

✅ À faire​

❌ À éviter​

Structure complète de la réponse​

Performances​

Voir aussi​