InfraNode

The open-data REST API for Germany: a keyless HTTP API for German
public-infrastructure open data, also available as an MCP server.

German cities publish a lot of open data, but every source has its own format,
fields and quirks, and several need portal registration. InfraNode normalizes
~20 categories, weather (DWD), air quality (UBA), public transit (incl. realtime
departures), traffic, electricity price (SMARD), land values (BORIS), parking,
charging, water levels, demographics, energy and more, for 84+ German cities
behind one interface. No API key, no account. Every response uses one
canonical { data, meta } envelope with per-record license and attribution. The
same data is also exposed as an MCP server (12 lean read-only tools covering 65
data types) for AI agents.
Start with the one-call get_city_overview: it returns a catalog of every data
type available for a city plus a live highlights snapshot, so agents discover the
full breadth, not just weather. InfraNode is actively growing, with more data
types and cities added regularly.

Sources include the Deutscher Wetterdienst (DWD), Umweltbundesamt (UBA),
Mobilithek/DELFI, GovData, OpenStreetMap, Bundesnetzagentur, KBA, DIVI and more.

See it in action

A single get_city_overview("koeln") call: current weather, official air
quality, DWD warnings, live train departures with delays, roadworks and the full
per-city data catalog, from one keyless endpoint. Try any city live at
infranode.dev.

How it works

One shared HTTP client fans out to the upstream sources, each response is mapped
into the canonical schema, license-gated with its attribution and cached in Redis
(with stale-on-error fallback), then served through both a REST API and an MCP
server. A failing upstream degrades to source_status, it never fails the call.

flowchart LR
    subgraph SRC["25+ German open-data sources"]
        direction TB
        S1["DWD, UBA<br/>weather, air"]
        S2["Mobilithek, DELFI, DB<br/>transit, realtime"]
        S3["SMARD, BNetzA, MaStR<br/>energy"]
        S4["BORIS, GovData, OSM,<br/>DIVI, KBA, ..."]
    end

    subgraph CORE["InfraNode core"]
        direction TB
        N["Normalize<br/>one canonical schema"] --> L["License-gate<br/>per-record attribution"] --> C["Redis cache<br/>stale-on-error fallback"]
    end

    SRC --> CORE
    CORE --> API["REST API<br/>infranode.dev/api/v1<br/>84 cities, keyless"]
    CORE --> MCP["MCP server<br/>mcp.infranode.dev<br/>12 read-only tools"]
    API --> APPS["Apps &amp; dashboards"]
    MCP --> AGENTS["AI agents<br/>Claude, ChatGPT"]

If InfraNode saves you a data integration, a star helps other developers find it.

Quickstart

Base URL https://infranode.dev/api/v1. No key, no account, just call it:

curl https://infranode.dev/api/v1/cities/koeln/weather

{
  "data": {
    "city_slug": "koeln",
    "observed_at": "2026-06-18T13:00:00Z",
    "source": "dwd",
    "attribution": { "text": "Datenbasis: Deutscher Wetterdienst", "modified": true },
    "payload": { "kind": "weather", "temperature_c": 30.4, "humidity": 43.0, "station_id": "02667" }
  },
  "meta": { "source_status": "ok", "cache_status": "hit", "correlation_id": "..." }
}

Every response follows the same { data, meta } envelope: each record carries
its attribution (license + source), and meta.source_status tells you whether
the upstream source delivered data, so a dead source degrades gracefully instead
of failing the call.

Tip: call /api/v1/cities first to discover valid city slugs (e.g. koeln,
berlin, hamburg), then call any city-scoped endpoint.

The full interactive reference and per-city coverage live at
infranode.dev. The
InfraNode API on the Postman API Network
mirrors every endpoint with real example responses, so you can try the
InfraNode API Postman collection
in the browser without an API key.

Data (84 cities, 101 endpoints)

Every category below is a REST endpoint under /api/v1/cities/{slug}/<key>.
Over MCP the same data comes through 12 lean tools: a few named ones
(get_city_overview, weather, air_quality, pois, compare, live boards)
plus one generic get_city_resource(slug, resource=<key>) for every other data
type (its resource enum lists all 67 keys).

How it behaves

• Keyless & read-only. No credentials, no writes, no user accounts.
• Canonical envelope. { data, meta } with per-source status and attribution.
• Graceful degradation. A failing upstream returns source_status, not an error.
• Safe by design. SSRF and injection gates validate every request; inputs are checked against fixed allowlists.

See SECURITY.md for the security model.

Use it as an MCP server

The same API is exposed as a remote MCP server, so AI agents can call all 65
endpoints as tools. One line with Claude Code:

claude mcp add --transport http infranode https://mcp.infranode.dev/mcp

Any other MCP client, point it at the remote endpoint (Streamable HTTP):

{
  "mcpServers": {
    "infranode": { "url": "https://mcp.infranode.dev/mcp" }
  }
}

• Cursor / Windsurf: add the block above to ~/.cursor/mcp.json (or the app's MCP settings).
• VS Code: code --add-mcp '{"name":"infranode","url":"https://mcp.infranode.dev/mcp"}'
• Claude Desktop: add the same mcpServers block to your claude_desktop_config.json.
• ChatGPT: add a connector with the URL https://mcp.infranode.dev/mcp.

All tools are annotated readOnlyHint: true / destructiveHint: false /
idempotentHint: true, so MCP clients can safely auto-allow them. The MCP layer
also ships ready-made prompts (city_briefing, compare_air_quality,
commute_check) and resources (infranode://cities, infranode://sources).
Full install guide, the complete tool manifest with example outputs, the
permission model and an example transcript are in
docs/mcp-install.md. The registry manifest is
server.json.

Use it in ChatGPT (Custom GPT action)

Ready-made GPT: German City Data (InfraNode)
is listed in the GPT Store (Research & Analysis) and works out of the box.

To build your own: InfraNode ships a curated OpenAPI spec for GPT
actions: 23 of the most useful operations (ChatGPT allows at most 30 per
action), keyless, all GET.

1. In the GPT editor open Configure →
   Actions → Create new action → Import from URL and paste
   https://infranode.dev/actions/openapi.json.
2. Leave authentication at None; as privacy policy use
   https://infranode.dev/en/privacy/.
3. Tell the GPT in its instructions to start with getCityOverview(slug),
   resolve city names via getCities, and cite data.attribution (the data
   licences require attribution).

Details and recommended instructions:
infranode.dev/en/chatgpt/. The spec is
generated from docs/openapi.yaml by scripts/build_actions_spec.py.

Alternatives and how InfraNode compares

Other MCP servers cover parts of the German or European data space. InfraNode is
the broadest for city-level open data, and the projects below often complement
each other:

• germany-mcp-server federal and government data (Autobahn, DWD, NINA, SMARD, Bundestag). Nationwide, no per-city breadth.
• db-mcp-server / db-timetable-mcp Deutsche Bahn rail timetables only.
• mcp-server-public-transport public transport across Europe; in Germany it covers Berlin/Brandenburg (VBB).
• Single-city servers (e.g. Munich, Berlin) cover one city each.

InfraNode covers 84 German cities and 67 data types behind one keyless, hosted
endpoint, from environment and mobility to energy, economy and city life. Full
side-by-side comparison:
infranode.dev/en/mcp-comparison.

Self-host (optional)

You don't need to, the hosted endpoint above is the fastest path. But the code
is open. Run the API stack locally with Docker (Compose v2):

cp .env.example .env          # example config, contains NO real secrets
docker compose -f deploy/docker-compose.yml up
curl http://localhost/api/v1/health   # -> {"status":"ok","version":"1.0.0","redis":true}

To run the MCP server itself locally over stdio (against the public API):

uv sync --group mcp
INFRANODE_MCP_API_BASE=https://infranode.dev/api/v1 uv run python -m infranode.mcp.server

All settings use the INFRANODE_ env prefix (see .env.example); each data
source is toggled by its own INFRANODE_ENABLE_* flag. Real secrets are never
committed, only .env.example is versioned and CI runs a gitleaks scan.

License: code and data are separate

• Code: Apache-2.0 (see LICENSE).
• Data: the open data served through InfraNode keeps the licenses of its
  upstream sources (e.g. ODbL for OpenStreetMap, DL-DE-BY for GovData, attribution
  for DWD). These data licenses and attribution are tracked separately in
  DATA-LICENSES.md. The Apache-2.0 license covers only the API source code, not
  the passed-through data.

Contributing

Contributions are welcome. Setup, gate commands and the secret rule are in
CONTRIBUTING.md. To add a new data source, start with the
declarative source registry in src/infranode/registry/source_specs.py (one
SourceSpec entry per upstream); CONTRIBUTING.md has the full checklist.