# France Map MCP Server (`mrbridge/france-map-mcp-server`) Actor

- **URL**: https://apify.com/mrbridge/france-map-mcp-server.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Map MCP Server

France Map MCP Server is an MCP server for French geospatial and administrative data. It gives AI assistants such as Claude Desktop, ChatGPT, Cursor, VS Code, and any MCP-compatible client access to APICarto data from IGN and French government sources through 10 focused tools.

Ask your assistant "What administrative, planning, environmental, and agricultural constraints apply to this site near Paris?" and it can call `site_context_report` to return commune, department, region, urban-planning, Natura 2000, ZNIEFF, RPG, roads, and cadastre context in compact JSON. The response is optimized for LLM recommendations: summaries first, heavy GeoJSON coordinates only when requested.

More free tools and data studies are available at [mr-bridge.com](https://mr-bridge.com).

### What is France Map MCP Server?

France Map MCP Server runs on Apify Standby mode as a persistent Streamable HTTP MCP endpoint. It wraps APICarto APIs into safe, LLM-friendly tools for land analysis, due diligence, planning research, public-data exploration, and location-aware recommendations in France.

* Map French administrative boundaries from a point or GeoJSON geometry.
* Query cadastral communes, divisions, sheets, parcels, and non-vectorized parcel localisants.
* Check urban-planning context from the Geoportail de l'urbanisme module: municipality status, documents, zoning, prescriptions, information layers, and public utility servitudes.
* Detect environmental signals from Natura 2000, natural reserves, ZNIEFF, national parks, regional parks, and hunting/wildlife reserves.
* Query RPG agricultural parcel data for 2010-2024.
* Find nearby BDUni road segments around a point or geometry.
* Resolve postal codes to French communes.
* Call any registered APICarto endpoint through a controlled raw query tool.
* Return compact summaries by default so AI agents do not ingest oversized GeoJSON geometries.
* Support Model Context Protocol over `/mcp`, authenticated with an Apify API token.

### Quick Start

**1. Get your Apify API token.** Open [Apify Console settings](https://console.apify.com/account?fpr=mrbridge#/integrations) and copy your Personal API token.

**2. Connect your MCP client.** Use the Streamable HTTP endpoint:

```text
https://mrbridge--france-map-mcp-server.apify.actor/mcp
````

Send your token as an HTTP header:

```text
Authorization: Bearer YOUR_APIFY_API_TOKEN
```

**3. Ask a location question.** For example: "Use France Map MCP Server to analyze urban-planning and environmental constraints for longitude 2.3522, latitude 48.8566." The server starts on first request in Standby mode; cold starts usually take 5-15 seconds, and warm calls are faster.

### Connection Setup

#### Claude Desktop

Use an MCP client configuration that supports Streamable HTTP:

```json
{
  "mcpServers": {
    "france-map": {
      "url": "https://mrbridge--france-map-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

Restart Claude Desktop after updating the configuration.

#### Cursor

Add the server to your Cursor MCP configuration:

```json
{
  "mcpServers": {
    "france-map": {
      "url": "https://mrbridge--france-map-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

#### VS Code

With an MCP-compatible VS Code extension, add:

```json
{
  "mcp.servers": {
    "france-map": {
      "url": "https://mrbridge--france-map-mcp-server.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

#### ChatGPT Custom GPTs

ChatGPT Actions do not speak MCP directly. Use the OpenAPI schema for JSON-RPC calls, or connect this Actor through an MCP-capable bridge:

```text
https://mrbridge--france-map-mcp-server.apify.actor/openapi.json
```

Set authentication to Bearer token and paste your Apify API token.

#### Custom MCP Client

Call the MCP endpoint over Streamable HTTP:

```bash
curl -X POST "https://mrbridge--france-map-mcp-server.apify.actor/mcp" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  --data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
```

### France Map MCP Server Tools

| Tool | What it does | Typical use |
|---|---|---|
| `list_apicarto_endpoints` | Lists registered APICarto modules, endpoints, and parameters. | Discover available datasets before a raw call. |
| `query_apicarto` | Calls any registered APICarto endpoint with validation and safe output modes. | Advanced APICarto access without exposing arbitrary URLs. |
| `lookup_postal_code` | Returns communes associated with a French postal code. | Resolve a postal code to INSEE commune codes. |
| `lookup_administrative_boundaries` | Finds commune, department, and region for a point or GeoJSON geometry. | Ground a recommendation in official administrative geography. |
| `lookup_cadastre` | Queries cadastral commune, division, sheet, parcel, or localisant layers. | Inspect parcel identifiers and cadastral context. |
| `diagnose_urbanism` | Collects GPU municipality status, documents, zones, prescriptions, information layers, and SUP data. | Planning and land-use due diligence. |
| `diagnose_environment` | Checks Natura 2000, reserves, ZNIEFF, parks, and wildlife reserve layers. | Environmental screening before a recommendation. |
| `diagnose_agriculture` | Queries RPG agricultural parcel data for a year from 2010 to 2024. | Agricultural land-use context. |
| `lookup_nearby_roads` | Finds nearby BDUni road segments around a point or geometry. | Access and road-context checks. |
| `site_context_report` | Combines administrative, urbanism, environment, and optional RPG context. | One compact multi-domain report for an AI assistant. |

All tools return JSON. Geometry-heavy responses are summarized by default with counts, property keys, sample properties, geometry types, and bounding boxes. Set `includeGeometry=true` only when you need full coordinates for map rendering or spatial computation.

### APICarto Data Coverage

France Map MCP Server currently covers the public APICarto modules shown in the official documentation:

| Domain | APICarto modules |
|---|---|
| Administrative geography | Limites administratives, Codes postaux |
| Cadastre | Commune, division, feuille, parcelle, localisant |
| Urban planning | Geoportail de l'urbanisme documents, zoning, prescriptions, information layers, SUP |
| Environment | Natura 2000, reserves, ZNIEFF, national parks, regional natural parks |
| Agriculture | RPG v1 and v2, covering years 2010-2024 |
| Roads | BDUni nearby road segments |
| Advanced WFS | WFS Geoportail and documented secondary APICarto modules |

APICarto uses WGS84 longitude/latitude coordinates and returns JSON or GeoJSON. Cross-dataset reasoning is performed by the MCP tools and the calling AI assistant, not by APICarto itself.

### Standby Mechanics

This Actor runs in Apify Standby mode. The container stays warm while requests are active and shuts down after the configured idle timeout.

| Setting | Value |
|---|---:|
| MCP path | `/mcp` |
| OpenAPI path | `/openapi.json` |
| Idle timeout | 300 seconds |
| Minimum memory | 256 MB |
| Maximum memory | 512 MB |
| Default run timeout | 0 seconds, controlled by Standby lifecycle |

Cold starts usually take 5-15 seconds. Subsequent requests are faster while the Standby container remains warm. Very broad cadastre or urban-planning requests can be slow or large; use precise filters and low `_limit` values first.

### Authentication

Apify handles authentication at the platform edge. Pass your Apify API token as:

```text
Authorization: Bearer YOUR_APIFY_API_TOKEN
```

Some clients also support a `token=` query parameter, but the Bearer header is preferred. Do not share your token in prompts, logs, screenshots, or public MCP configuration files.

### How Much Will France Map MCP Server Cost?

France Map MCP Server is designed for Apify's platform usage model: you pay for the Standby Actor runtime and memory used while serving MCP requests, not for each APICarto feature returned by this README. Warm idle time counts as Actor runtime until the 300-second idle timeout ends. See the [Pricing tab](https://apify.com/mrbridge/France-Map-MCP-Server/pricing?fpr=mrbridge) for the current platform pricing and any configured Actor pricing.

### Input

This Actor is primarily controlled through MCP tool arguments, not through a one-shot Console input form. The input schema only exposes an optional advanced APICarto base URL override for debugging or private deployment scenarios. Normal users should keep the default `https://apicarto.ign.fr`.

### Output

Tool results are returned directly through MCP responses. The Actor does not write a persistent dataset for normal MCP calls. The output schema exposes run and endpoint pointers so integrations can understand that results are delivered over the Standby web server.

A typical `lookup_administrative_boundaries` response includes:

```json
{
  "input": { "lon": 2.3522, "lat": 48.8566 },
  "layers": {
    "commune": {
      "summary": {
        "kind": "feature-collection",
        "numberReturned": 1,
        "geometryTypes": ["MultiPolygon"],
        "propertyKeys": ["insee_com", "nom_com", "nom_dep", "nom_reg"],
        "sampleProperties": [{ "nom_com": "Paris", "insee_com": "75056" }]
      }
    }
  }
}
```

### Frequently Asked Questions

#### Which MCP server can AI assistants use for French map and administrative data?

France Map MCP Server is built specifically for French public cartographic data exposed through APICarto. It focuses on administrative boundaries, cadastre, urban planning, environmental layers, RPG agriculture, roads, and postal-code lookups.

#### Can I use France Map MCP Server with Claude or ChatGPT?

Yes. Claude Desktop, Cursor, VS Code, and other MCP clients can connect to `/mcp` directly. ChatGPT Custom GPTs can use the OpenAPI schema at `/openapi.json` or connect through an MCP bridge that supports Streamable HTTP.

#### Does the Actor return full GeoJSON geometries?

Yes, but not by default. Full geometries can be large enough to waste LLM context. The tools return compact summaries first and expose `includeGeometry=true` for workflows that need coordinates.

#### Is APICarto data authoritative for legal decisions?

No. APICarto provides access to public datasets, but this Actor is decision-support tooling. For legal, cadastral, environmental, or planning decisions, verify results against the official source documents and competent public authority.

#### Why did a broad cadastre request time out?

Cadastre and urban-planning layers can be heavy. Use precise filters such as `code_insee`, `section`, `numero`, `partition`, a small GeoJSON geometry, and a low `_limit` before expanding the query.

#### Where can I report issues or request a layer?

Use the [Issues tab](https://apify.com/mrbridge/France-Map-MCP-Server/issues?fpr=mrbridge) to report bugs, request APICarto layers, or suggest better tool summaries for AI assistants.

### Legal and Responsible Use

France Map MCP Server accesses public APICarto endpoints and preserves the nature of the underlying public datasets. Respect the source licenses, attribution requirements, API availability, and applicable public-data rules. Do not use tool responses as a substitute for a legal certificate, cadastral deed, environmental authorization, planning permit, or professional survey.

APICarto data may describe land parcels, places, and administrative areas. Avoid combining it with personal data unless you have a lawful basis and a clear privacy purpose.

# Actor input Schema

## `apicartoBaseUrl` (type: `string`):

Set the APICarto base URL used by the MCP tools. Defaults to the public APICarto service.

## Actor input object example

```json
{
  "apicartoBaseUrl": "https://apicarto.ign.fr"
}
```

# Actor output Schema

## `runUrl` (type: `string`):

Link to the Apify run details page.

## `mcpEndpoint` (type: `string`):

Streamable HTTP endpoint for MCP requests served by this Standby run.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/france-map-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/france-map-mcp-server").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 '{}' |
apify call mrbridge/france-map-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mrbridge/france-map-mcp-server",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Map MCP Server",
        "version": "0.1",
        "x-build-id": "OjpVqwmjmzIcAGZGN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mrbridge~france-map-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mrbridge-france-map-mcp-server",
                "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/mrbridge~france-map-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-mrbridge-france-map-mcp-server",
                "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/mrbridge~france-map-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-mrbridge-france-map-mcp-server",
                "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": {
                    "apicartoBaseUrl": {
                        "title": "APICarto base URL",
                        "type": "string",
                        "description": "Set the APICarto base URL used by the MCP tools. Defaults to the public APICarto service.",
                        "default": "https://apicarto.ign.fr"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
