# France Property Risk Scraper (`automation-lab/france-property-risk-scraper`) Actor

Bulk enrich French addresses with official Géorisques hazard, environmental, ICPE, radon, seismic, pollution, and cavity risk signals.

- **URL**: https://apify.com/automation-lab/france-property-risk-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## France Property Risk Scraper

France Property Risk Scraper enriches French property addresses and coordinates with official public risk data.

It combines the French national address geocoder with Géorisques endpoints so property teams can review environmental and natural-hazard signals in bulk instead of opening one public page at a time.

### What does France Property Risk Scraper do?

The actor returns one structured row per property.

Each row starts from either a postal address or a coordinate pair.

For address inputs, the actor geocodes the property with `api-adresse.data.gouv.fr`.

Then it calls selected Géorisques modules for the matching location and commune.

The output includes normalized address data, coordinates, INSEE commune codes, seismic zoning, radon potential, PPR / GASPAR risk labels, nearby ICPE industrial facilities, polluted-site indicators, underground cavities, source URLs, and endpoint status evidence.

Use it when you need repeatable risk enrichment for many French properties.

### Who is it for?

Real-estate acquisition teams use it to screen properties before spending analyst time on deeper diligence.

Notaires, legal operations teams, and transaction coordinators use it to add official context to address lists during document review.

Insurers and lenders use it to pre-screen portfolios for commune-level and nearby-site risk indicators.

Property investors use it to compare opportunities across cities, regions, and asset classes.

Data teams use it to join public risk signals into CRMs, BI dashboards, underwriting models, and internal property databases.

### Why use this actor?

Manual public-risk checks are slow when you have hundreds or thousands of addresses.

This actor makes the process consistent.

It uses public endpoints, emits typed fields, and records which source modules answered for each row.

That means your team can filter, sort, and audit the results after the run.

The actor is also useful as a first-pass triage layer: it highlights records that need more legal, engineering, insurance, or environmental review.

### Data sources used

The actor uses public French government data services.

- `api-adresse.data.gouv.fr` for address normalization and geocoding.
- `georisques.gouv.fr` public APIs for natural and environmental risk modules.
- Commune-level codes returned by the geocoder or provided directly in coordinate input.
- Coordinate/radius searches for nearby site modules.

No login, private cookies, or browser automation are required.

The actor does not claim to replace official transaction documents or professional expert review.

### What data can you extract?

The dataset includes address and location fields:

- input label
- original input address
- normalized address
- latitude
- longitude
- geocode score
- INSEE code
- commune
- postcode

The dataset includes natural-hazard fields:

- seismic zone code
- seismic zone label
- radon potential class
- PPR / GASPAR risk count
- PPR / GASPAR risk labels

The dataset includes nearby environmental indicators:

- ICPE industrial-site count
- ICPE industrial-site sample objects
- polluted-site count
- polluted-site sample objects
- underground-cavity count
- underground-cavity sample objects

The dataset includes audit fields:

- source endpoint statuses
- source URLs
- scrape timestamp

### Output fields overview

| Field | Meaning |
| --- | --- |
| `inputLabel` | Human-readable label for the property input. |
| `normalizedAddress` | Address selected by the national geocoder. |
| `latitude` / `longitude` | Coordinates used for Géorisques lookups. |
| `inseeCode` | Commune code used for commune-level modules. |
| `seismicZoneLabel` | Seismic zoning label when returned by the source. |
| `radonPotentialClass` | Radon potential class when available. |
| `pprRiskCount` | Number of PPR / GASPAR risk labels returned. |
| `industrialSiteCount` | Count of nearby ICPE facilities found. |
| `pollutedSiteCount` | Count of nearby polluted or historical industrial records found. |
| `cavityCount` | Count of nearby underground cavity records found. |
| `sourceEndpointStatuses` | Per-module status evidence for audit and debugging. |
| `sourceUrls` | Public source URLs called for the row. |

### How much does it cost to enrich French property risk data?

Pricing uses pay-per-event billing.

A small `start` event is charged once per run.

An `item` event is charged for each property row returned.

Current actor configuration:

- Start: `$0.005` per run.
- FREE item price: `$0.00006366` per property row.
- BRONZE item price: `$0.000055356` per property row.
- SILVER item price: `$0.000043178` per property row.
- GOLD item price: `$0.000033214` per property row.
- PLATINUM item price: `$0.000022142` per property row.
- DIAMOND item price: `$0.0000155` per property row.

Example: on the BRONZE tier, a run with 1,000 returned property rows costs about `$0.060356` before any platform-side rounding or plan-specific changes.

The default input is intentionally small, so a first trial run stays cheap.

### Input options

Use `addressesText` when you have postal addresses.

Enter one French address per line.

Include street, postcode, and city whenever possible.

Use `coordinatesJson` when your database already contains coordinates.

Coordinate objects can include `lat`, `lon`, `label`, and `inseeCode`.

Providing `inseeCode` with coordinates helps commune-level modules such as radon and PPR / GASPAR.

Use `maxItems` to cap the run.

Use `searchRadiusMeters` to control nearby-site search distance.

Use `maxNearbySites` to limit how many example objects are stored for each nearby-site module.

### Risk module switches

You can enable or disable modules to match your workflow.

- `includeSeismic` calls seismic zoning data.
- `includeRadon` calls radon potential data when an INSEE code is available.
- `includePprRisks` calls commune-level PPR / GASPAR risks when an INSEE code is available.
- `includeIndustrialSites` searches nearby ICPE facilities.
- `includePollutedSites` searches nearby polluted-site and historical industrial records.
- `includeCavities` searches nearby underground cavity records.

Disable modules when you only need part of the dataset or want smaller source-status arrays.

### Address workflow

1. Paste addresses into `addressesText`, one per line.
2. Keep `maxItems` low for the first run.
3. Run the actor.
4. Review geocode scores and normalized addresses.
5. Filter rows with relevant risk counts or labels.
6. Export the dataset to CSV, Excel, JSON, or your downstream system.

This workflow is best for property lists from spreadsheets, CRMs, notarial intake systems, or acquisition pipelines.

### Coordinate workflow

Use coordinates when your source system already geocoded the properties.

Example `coordinatesJson`:

```json
{
  "coordinates": [
    {
      "lat": 48.8555,
      "lon": 2.36041,
      "label": "10 Rue de Rivoli, Paris",
      "inseeCode": "75104"
    }
  ]
}
````

Coordinate input avoids ambiguity in address matching.

It is useful for GIS teams, insurers, lenders, and data warehouses that already store location geometry.

### Example input

```json
{
  "addressesText": "10 Rue de Rivoli, 75004 Paris\n20 Avenue Jean Médecin, 06000 Nice\n1 Place Bellecour, 69002 Lyon",
  "coordinatesJson": { "coordinates": [] },
  "maxItems": 3,
  "searchRadiusMeters": 1000,
  "maxNearbySites": 5,
  "includeSeismic": true,
  "includeRadon": true,
  "includePprRisks": true,
  "includeIndustrialSites": true,
  "includePollutedSites": true,
  "includeCavities": true
}
```

Start with a few rows, inspect output quality, then scale to larger batches.

### Example output

```json
{
  "inputLabel": "10 Rue de Rivoli, 75004 Paris",
  "normalizedAddress": "10 Rue de Rivoli 75004 Paris",
  "latitude": 48.8555,
  "longitude": 2.36041,
  "inseeCode": "75104",
  "commune": "Paris",
  "seismicZoneLabel": "Zone de sismicité très faible",
  "radonPotentialClass": "1",
  "pprRiskCount": 4,
  "industrialSiteCount": 2,
  "pollutedSiteCount": 8,
  "cavityCount": 0,
  "sourceEndpointStatuses": [
    { "module": "geocode", "ok": true, "status": 200 }
  ],
  "sourceUrls": ["https://api-adresse.data.gouv.fr/search/"],
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
```

Exact values depend on source data and API responses at run time.

### How to read the risk counts

Counts are screening indicators.

A non-zero count means the public source returned matching records for the module and location.

It does not automatically mean a property is unsafe, uninsurable, or unsuitable.

Use counts to prioritize rows for deeper review.

Always inspect the source URLs and official source records before making high-stakes decisions.

### Tips for better matches

Use full French addresses with postcode and commune name.

Avoid ambiguous building names without street context.

If you already have coordinates, pass them directly.

Add `inseeCode` to coordinate rows when possible.

Use a radius that fits your diligence policy; a larger radius can find more nearby sites but may also add less relevant records.

Keep `maxNearbySites` moderate so rows stay readable in CSV and spreadsheet exports.

### Troubleshooting geocoding

If a row has no normalized address, the address may be outside France, incomplete, misspelled, or too ambiguous.

Try adding postcode and city.

If a geocode score looks low, review the normalized address before relying on downstream risk fields.

For portfolio work, keep the original address in your own system and compare it against `normalizedAddress`.

### Troubleshooting risk modules

A zero count can mean no matching records were found for that module.

It can also mean a module could not run because required location data was missing.

Check `sourceEndpointStatuses` for each row.

If a public source is temporarily unavailable, rerun the affected rows later or disable the module that is failing.

### Integrations for due diligence teams

Export CSV for analyst review.

Send JSON to a data warehouse for portfolio-level scoring.

Connect Apify webhooks to trigger alerts when a batch finishes.

Join results with acquisition pipeline records by `inputLabel` or your own external IDs in labels.

Use the actor as an enrichment step before creating internal diligence tickets.

### Integrations for insurers and lenders

Use the output to pre-screen addresses before underwriting review.

Add risk counts to credit, policy, or collateral-review dashboards.

Separate rows with non-zero PPR, ICPE, polluted-site, or cavity signals for analyst triage.

Store `sourceUrls` and `scrapedAt` so you can document when public-source checks were performed.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/france-property-risk-scraper').call({
  addressesText: '10 Rue de Rivoli, 75004 Paris\n1 Place Bellecour, 69002 Lyon',
  maxItems: 2,
  searchRadiusMeters: 1000,
  maxNearbySites: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/france-property-risk-scraper').call(run_input={
    'addressesText': '10 Rue de Rivoli, 75004 Paris\n1 Place Bellecour, 69002 Lyon',
    'maxItems': 2,
    'searchRadiusMeters': 1000,
    'maxNearbySites': 5,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~france-property-risk-scraper/runs?token='$APIFY_TOKEN \
  -H 'Content-Type: application/json' \
  -d '{"addressesText":"10 Rue de Rivoli, 75004 Paris\n1 Place Bellecour, 69002 Lyon","maxItems":2}'
```

After the run succeeds, fetch dataset items from the run's default dataset.

### MCP setup for AI agents

Use Apify MCP when an AI agent should enrich property lists during a research or diligence workflow.

For Claude Code, add a dedicated MCP tool entry:

```bash
claude mcp add apify-france-property-risk --url "https://mcp.apify.com/?tools=automation-lab/france-property-risk-scraper"
```

For Claude Desktop, add an MCP server that exposes this actor only:

```json
{
  "mcpServers": {
    "apify-france-property-risk": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=automation-lab/france-property-risk-scraper"
      ]
    }
  }
}
```

Example prompt:

> Use the France Property Risk Scraper to enrich these French property addresses, then summarize rows with non-zero PPR, ICPE, polluted-site, or cavity counts.

This keeps the AI workflow focused on this property-risk enrichment tool.

### Quality and auditability

Every output row includes endpoint-status evidence.

Use those statuses to distinguish “no records found” from “source request failed”.

Rows also include source URLs for traceability.

For regulated decisions, save the dataset export with the run ID and timestamp.

This makes it easier to reproduce which public-source checks were available when the enrichment was performed.

### Limitations

Public APIs can change, return partial data, or have temporary downtime.

Nearby-site modules depend on coordinate accuracy and radius choices.

Commune-level signals may not describe parcel-level conditions.

Some risk categories require official documents, expert reports, or local authority confirmation.

Treat this actor as bulk screening and enrichment, not as a final legal opinion.

### Legality and responsible use

The actor accesses public government APIs and address-geocoding data.

Only upload data you are allowed to process.

If address lists contain personal data, follow applicable privacy rules and internal retention policies.

Do not use the output as the only basis for legal, financial, insurance, or safety decisions.

Validate material findings against official sources and professional advice.

### FAQ: can I use coordinates only?

Yes.

Provide coordinates in `coordinatesJson`.

Include `inseeCode` when available so commune-level modules can run.

Without `inseeCode`, coordinate-radius modules can still work, but commune-level modules may be limited.

### FAQ: does it replace an ERP report?

No.

It is a bulk enrichment and triage actor.

Use it to identify addresses that deserve closer review.

For formal transaction requirements, official ERP documents and professional checks may still be needed.

### FAQ: why are some module fields null?

A module field can be null when the module was disabled, required input was missing, the source returned no usable value, or the source request failed.

Check `sourceEndpointStatuses` to understand the reason.

The actor keeps row-level evidence so missing values are easier to diagnose.

### Related Automation Lab actors

Use these actors for adjacent France and public-data workflows:

- [France SIRENE Company Registry Scraper](https://apify.com/automation-lab/france-sirene-company-registry-scraper) for French company registry enrichment.
- [France Public Administration Directory Scraper](https://apify.com/automation-lab/france-public-administration-directory-scraper) for public administration contacts and entities.
- [EPA ECHO Facility Compliance Scraper](https://apify.com/automation-lab/epa-echo-facility-compliance-scraper) for US environmental compliance facility data.
- [Bulk URL Status Checker](https://apify.com/automation-lab/bulk-url-status-checker) for monitoring source links in downstream reports.

### Suggested portfolio workflow

Run this actor on a property list.

Export rows with non-zero risk counts.

Join those rows back to asset IDs in your internal system.

Create review tasks for analysts.

Attach source URLs and endpoint statuses to each review task.

Archive the dataset export with the acquisition or underwriting record.

### Support and feedback

If a source endpoint changes or a module starts returning unexpected statuses, share a run ID and a small input example.

Include whether the issue affects geocoding, seismic, radon, PPR / GASPAR, ICPE, polluted sites, or cavities.

That context makes it faster to diagnose whether the problem is source data, input format, or actor logic.

# Actor input Schema

## `addressesText` (type: `string`):

Postal addresses to geocode with api-adresse.data.gouv.fr before calling Géorisques. Use full street, postcode, and city for best matches.

## `coordinatesJson` (type: `object`):

Optional known coordinates as {"coordinates":\[{"lat":48.8555,"lon":2.36041,"label":"10 Rue de Rivoli","inseeCode":"75104"}]}. These are used after address rows.

## `maxItems` (type: `integer`):

Maximum input properties to process in this run.

## `searchRadiusMeters` (type: `integer`):

Radius around each coordinate for nearby industrial sites, polluted sites, and cavities.

## `maxNearbySites` (type: `integer`):

Maximum facility/site examples stored in each output row while count fields still show total API result counts.

## `includeSeismic` (type: `boolean`):

Call the Géorisques seismic zoning endpoint for each coordinate.

## `includeRadon` (type: `boolean`):

Call the Géorisques radon endpoint when an INSEE code is available.

## `includePprRisks` (type: `boolean`):

Call the commune-level GASPAR risks endpoint when an INSEE code is available.

## `includeIndustrialSites` (type: `boolean`):

Find nearby classified industrial facilities around each coordinate.

## `includePollutedSites` (type: `boolean`):

Find nearby polluted sites and CASIAS records around each coordinate.

## `includeCavities` (type: `boolean`):

Find nearby underground cavity records around each coordinate.

## Actor input object example

```json
{
  "addressesText": "10 Rue de Rivoli, 75004 Paris\n20 Avenue Jean Médecin, 06000 Nice\n1 Place Bellecour, 69002 Lyon",
  "coordinatesJson": {
    "coordinates": []
  },
  "maxItems": 3,
  "searchRadiusMeters": 1000,
  "maxNearbySites": 5,
  "includeSeismic": true,
  "includeRadon": true,
  "includePprRisks": true,
  "includeIndustrialSites": true,
  "includePollutedSites": true,
  "includeCavities": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "addressesText": `10 Rue de Rivoli, 75004 Paris
20 Avenue Jean Médecin, 06000 Nice
1 Place Bellecour, 69002 Lyon`,
    "coordinatesJson": {
        "coordinates": []
    },
    "maxItems": 3,
    "searchRadiusMeters": 1000,
    "maxNearbySites": 5,
    "includeSeismic": true,
    "includeRadon": true,
    "includePprRisks": true,
    "includeIndustrialSites": true,
    "includePollutedSites": true,
    "includeCavities": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/france-property-risk-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "addressesText": """10 Rue de Rivoli, 75004 Paris
20 Avenue Jean Médecin, 06000 Nice
1 Place Bellecour, 69002 Lyon""",
    "coordinatesJson": { "coordinates": [] },
    "maxItems": 3,
    "searchRadiusMeters": 1000,
    "maxNearbySites": 5,
    "includeSeismic": True,
    "includeRadon": True,
    "includePprRisks": True,
    "includeIndustrialSites": True,
    "includePollutedSites": True,
    "includeCavities": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/france-property-risk-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "addressesText": "10 Rue de Rivoli, 75004 Paris\\n20 Avenue Jean Médecin, 06000 Nice\\n1 Place Bellecour, 69002 Lyon",
  "coordinatesJson": {
    "coordinates": []
  },
  "maxItems": 3,
  "searchRadiusMeters": 1000,
  "maxNearbySites": 5,
  "includeSeismic": true,
  "includeRadon": true,
  "includePprRisks": true,
  "includeIndustrialSites": true,
  "includePollutedSites": true,
  "includeCavities": true
}' |
apify call automation-lab/france-property-risk-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/france-property-risk-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Property Risk Scraper",
        "description": "Bulk enrich French addresses with official Géorisques hazard, environmental, ICPE, radon, seismic, pollution, and cavity risk signals.",
        "version": "0.1",
        "x-build-id": "gyehuYbfP22vsyfQL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~france-property-risk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-france-property-risk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~france-property-risk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-france-property-risk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~france-property-risk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-france-property-risk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "addressesText": {
                        "title": "French addresses (one per line)",
                        "type": "string",
                        "description": "Postal addresses to geocode with api-adresse.data.gouv.fr before calling Géorisques. Use full street, postcode, and city for best matches."
                    },
                    "coordinatesJson": {
                        "title": "Coordinates JSON",
                        "type": "object",
                        "description": "Optional known coordinates as {\"coordinates\":[{\"lat\":48.8555,\"lon\":2.36041,\"label\":\"10 Rue de Rivoli\",\"inseeCode\":\"75104\"}]}. These are used after address rows."
                    },
                    "maxItems": {
                        "title": "Maximum properties",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum input properties to process in this run.",
                        "default": 3
                    },
                    "searchRadiusMeters": {
                        "title": "Nearby site radius (meters)",
                        "minimum": 100,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Radius around each coordinate for nearby industrial sites, polluted sites, and cavities.",
                        "default": 1000
                    },
                    "maxNearbySites": {
                        "title": "Maximum nearby sites per module",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum facility/site examples stored in each output row while count fields still show total API result counts.",
                        "default": 5
                    },
                    "includeSeismic": {
                        "title": "Include seismic zoning",
                        "type": "boolean",
                        "description": "Call the Géorisques seismic zoning endpoint for each coordinate.",
                        "default": true
                    },
                    "includeRadon": {
                        "title": "Include radon potential",
                        "type": "boolean",
                        "description": "Call the Géorisques radon endpoint when an INSEE code is available.",
                        "default": true
                    },
                    "includePprRisks": {
                        "title": "Include PPR / GASPAR risks",
                        "type": "boolean",
                        "description": "Call the commune-level GASPAR risks endpoint when an INSEE code is available.",
                        "default": true
                    },
                    "includeIndustrialSites": {
                        "title": "Include ICPE / industrial sites",
                        "type": "boolean",
                        "description": "Find nearby classified industrial facilities around each coordinate.",
                        "default": true
                    },
                    "includePollutedSites": {
                        "title": "Include polluted sites (SSP/CASIAS)",
                        "type": "boolean",
                        "description": "Find nearby polluted sites and CASIAS records around each coordinate.",
                        "default": true
                    },
                    "includeCavities": {
                        "title": "Include underground cavities",
                        "type": "boolean",
                        "description": "Find nearby underground cavity records around each coordinate.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
