# Marktstammdatenregister (MaStR) Scraper — German Energy Units (`haketa/marktstammdatenregister-scraper`) Actor

Extract solar, wind, biomass, hydro & storage units from Germany's official MaStR energy registry. Filter by energy source, state, postal code, operator & status. Get operator names, capacity (kW), commissioning date & location for B2B leads and market research.

- **URL**: https://apify.com/haketa/marktstammdatenregister-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## Marktstammdatenregister Scraper — German Energy Units (Solar, Wind, Biomass & More)

Extract structured data on **Germany's energy units** — solar plants, wind turbines, biomass, hydro, battery storage and conventional power plants — from the **Marktstammdatenregister (MaStR)**, the official German market master data register for electricity and gas.

Filter by **energy source, federal state, city, postal code, operator and operational status**, and get clean records with the **operator name, capacity in kW, commissioning date and location** for every unit. Perfect for **B2B lead generation, market research, energy analytics and the German Energiewende**.

No code, no login, no account on the registry. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, HubSpot, Make, Zapier and n8n.

> **⚡ Built for solar & energy sales teams and analysts.** Every record carries the **operator, gross/net capacity, energy source and exact location (city + PLZ)** — ideal for targeted outreach and market sizing across Germany.

---

### 📋 What this scraper does

The German MaStR contains **millions of registered energy units** — from a 4 kW rooftop solar system to a 1,500,000 kW power plant. This actor turns that huge public register into a clean, structured dataset you can filter, analyse and feed into a CRM.

Choose your filters and it will:

- ✅ Collect every matching unit, page after page
- ✅ Return the **energy source** (Solar, Wind, Biomass, Hydro, Storage, Nuclear, …)
- ✅ Capture **gross capacity (Bruttoleistung)** and **net capacity (Nettonennleistung)** in kW
- ✅ Include the **operator name** for commercial operators (organisations)
- ✅ Break out the **location** — city (Ort) and postal code (PLZ)
- ✅ Report the **operational status** and **commissioning date**
- ✅ Add a direct **link to the official public detail page**
- ✅ De-duplicate every unit by its registry ID

---

### ⭐ Why choose this scraper

- **Targeted energy leads.** Filter to commercial operators (GmbH, Solarpark, Energie…) in a specific state or city and build outreach lists in minutes.
- **Every energy source.** Solar, wind, biomass, hydro, storage, hydrogen, geothermal and conventional plants — pick one or several.
- **Capacity intelligence.** Gross and net power on every record, so you can rank by plant size and target only the units that matter.
- **Precise geography.** City and postal code on each unit for territory planning, mapping and regional analysis.
- **Fast and economical.** Efficient extraction — hundreds of units in seconds at very low cost.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Solar & wind B2B leads** | Find commercial operators by energy source, state and city for direct sales and partnerships. |
| **Market research & sizing** | Measure how many units, and how much capacity, exist per state, energy source or year. |
| **Energy consultancy & O&M** | Build target lists of plant operators for maintenance, monitoring and advisory services. |
| **Investment & M&A** | Screen operating assets by capacity, technology and region for acquisition pipelines. |
| **Competitor & supplier mapping** | See who operates what, where — installers, funds and utilities across Germany. |
| **Grid & policy analytics** | Track the rollout of renewables, storage and the Energiewende at unit level. |
| **Data products & dashboards** | Feed a clean energy-asset feed into BI tools, GIS or a database. |

---

### 🚀 Quick start

1. Open the actor and pick a **Unit category** (default: *Electricity generation*).
2. Choose your filters — e.g. **Energy sources = Solar**, **Federal states = Bayern**, **Operational status = In operation**.
3. Set **Max units** and click **Start**.
4. Download your data from the **Storage → Dataset** tab.

Leave the filters empty to scrape across all of Germany, or combine several to zoom into exactly the segment you need.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Unit category** | select | Electricity generation (default), electricity consumption, gas generation or gas consumption. |
| **Energy sources** | multi-select | Solar, Wind, Biomass, Hydro, Storage, Nuclear, Hydrogen, Geothermal, Natural gas, Lignite, Hard coal and more. Empty = all. |
| **Federal states** | multi-select | One or more of the 16 German Bundesländer. Empty = all of Germany. |
| **Operational status** | multi-select | In operation (default), in planning, temporarily or permanently shut down. |
| **City (Ort)** | string | Exact city / municipality name, e.g. `Berlin`, `München`. |
| **Postal code (PLZ)** | string | Exact German postal code, e.g. `10115`. |
| **Operator name contains** | string | Match operators by name, e.g. `GmbH`, `Solarpark`, `Energie` (organisations only). |
| **Only commercial operators** | boolean | Keep only units with a named organisation as operator (private individuals are anonymised by the registry). |
| **Min / Max gross capacity (kW)** | integer | Keep only units within a capacity range. |
| **Sort by** | select | Newest first, oldest first, largest capacity first, or latest commissioning. |
| **Max units** | integer | Cap on total units returned. `0` = no limit. |
| **Proxy** | object | Apify Proxy (on by default; recommended for large runs). |

#### Example 1 — Solar plants in Bavaria, in operation

```json
{
  "unitCategory": "electricity-generation",
  "energyTypes": ["solar"],
  "states": ["bayern"],
  "operationalStatus": ["in-operation"],
  "maxItems": 1000
}
````

#### Example 2 — Large commercial wind operators nationwide

```json
{
  "unitCategory": "electricity-generation",
  "energyTypes": ["wind"],
  "onlyCommercial": true,
  "minCapacityKw": 1000,
  "sortBy": "capacity-desc",
  "maxItems": 500
}
```

#### Example 3 — Everything in one postal code

```json
{
  "unitCategory": "electricity-generation",
  "postalCode": "10115",
  "maxItems": 300
}
```

#### Example 4 — Battery storage in NRW

```json
{
  "unitCategory": "electricity-generation",
  "energyTypes": ["storage"],
  "states": ["nordrhein-westfalen"],
  "maxItems": 500
}
```

> **Tip:** Selecting several energy sources or states runs each one and merges the results, de-duplicated by unit ID. For a **min-capacity** filter, choose **Sort by = Largest capacity first** for the fastest runs.

***

### 📦 Output

Each unit becomes one dataset record:

```json
{
  "unitId": "6937017",
  "mastrNr": "SEE915790729133",
  "unitName": "SILUX Solarpark 1 GmbH & Co. KG",
  "category": "Electricity generation",
  "energySource": "Solare Strahlungsenergie",
  "status": "In Betrieb",
  "operatorName": "SILUX Solarpark 1 GmbH & Co. KG",
  "operatorMastrNr": "ABR911402260780",
  "isCommercial": true,
  "grossPowerKw": 162262.2,
  "netPowerKw": 111250,
  "solarModuleCount": 283878,
  "commissioningDate": "2024-02-06",
  "reportedDate": "2024-02-09",
  "lastUpdated": "2026-03-02",
  "city": "Böhlen",
  "postalCode": "04564",
  "parcel": "Kahnsdorf: 330/8 (Teilfläche) ...",
  "detailUrl": "https://www.marktstammdatenregister.de/MaStR/Einheit/Detail/IndexOeffentlich/6937017",
  "scrapedAt": "2026-07-02T00:00:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `unitId` | Registry unit ID (used for de-duplication and the detail URL). |
| `mastrNr` | Official MaStR unit number. |
| `unitName` | Display name of the unit. |
| `category` | Registry category (electricity/gas, generation/consumption). |
| `energySource` | Energy source (Solar, Wind, Biomass, …). |
| `status` | Operational status (In Betrieb, In Planung, …). |
| `operatorName` | Operator name for organisations (empty when the operator is an anonymised private individual). |
| `operatorMastrNr` | Operator's MaStR number. |
| `isCommercial` | `true` when the operator is a named organisation. |
| `grossPowerKw` | Gross capacity in kW (Bruttoleistung). |
| `netPowerKw` | Net nominal capacity in kW (Nettonennleistung). |
| `solarModuleCount` | Number of solar modules (solar units). |
| `commissioningDate` | Date the unit went into operation. |
| `reportedDate` | Date the unit was reported to the registry. |
| `lastUpdated` | Last update date in the registry. |
| `city` / `postalCode` | Location — city (Ort) and postal code (PLZ). |
| `parcel` | Cadastral parcel (Flurstück), where available. |
| `detailUrl` | Public detail page for the unit. |
| `scrapedAt` | Extraction timestamp. |

***

### 🔋 Energy sources you can filter

**Renewables & storage:** Solar, Wind, Biomass, Hydro (Wasser), Storage (Speicher), Hydrogen (Wasserstoff), Geothermal, Solar thermal.

**Conventional & other:** Natural gas (Erdgas), Lignite (Braunkohle), Hard coal (Steinkohle), Mine gas (Grubengas), Sewage gas, Mineral oil products, Heat (Wärme), Other gases, Non-biogenic waste, Nuclear (Kernenergie).

Select one, several, or none (for all sources).

***

### 🗺️ Federal states (Bundesländer)

Baden-Württemberg · Bayern (Bavaria) · Berlin · Brandenburg · Bremen · Hamburg · Hessen (Hesse) · Mecklenburg-Vorpommern · Niedersachsen (Lower Saxony) · Nordrhein-Westfalen (NRW) · Rheinland-Pfalz · Saarland · Sachsen (Saxony) · Sachsen-Anhalt · Schleswig-Holstein · Thüringen (Thuringia).

***

### 🧭 Tips for best results

- **Combine filters** (energy source + state + status) to zoom into a precise market segment.
- **Use `onlyCommercial`** or **Operator name contains `GmbH`** to focus on companies for B2B outreach.
- **Rank by capacity** with **Sort by = Largest capacity first** to surface the biggest plants first.
- **Add a min-capacity** to skip small rooftop systems and keep utility-scale assets.
- **Search by postal code** for hyper-local coverage, or by city for a whole municipality.
- **Schedule weekly runs** to track new registrations and status changes over time.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **CRM / Sheets / Airtable / Make / Zapier / n8n:** push results automatically.
- **API:** run and fetch data with the Apify API or the JS / Python clients.
- **Scheduling:** run on a schedule to keep an always-fresh energy-asset database.

***

### ❓ FAQ

**Do I need an account on the registry or an API key?**
No. You only need an Apify account.

**Which units are covered?**
Electricity generation and consumption units, plus gas generation and consumption — across all of Germany. Energy-source filtering applies to electricity generation.

**Why are some operator names empty?**
The registry anonymises private individuals. Companies and organisations are shown; individuals are not. Use **Only commercial operators** to keep just the named ones.

**Can I filter by capacity?**
Yes — set a minimum and/or maximum gross capacity in kW. For a minimum, sort by largest capacity first for the fastest runs.

**How do multiple energy sources or states work?**
Each selected value is fetched separately and merged into one dataset, de-duplicated by unit ID.

**Does it return duplicates?**
No. Units are de-duplicated by their registry ID across all filters.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** information that Germany's market master data register publishes for everyone to see. It does not log in or access private data. Personal data of private individuals is anonymised at source. Respect the registry's terms of use and applicable law, and use the data for lawful purposes such as market research, analytics and B2B outreach.

***

### 🛟 Support

Need an extra field or hit an issue? Open a ticket from the actor's **Issues** tab with your input configuration.

Happy sourcing! ⚡

# Actor input Schema

## `unitCategory` (type: `string`):

Which part of the registry to scrape. Electricity generation covers solar, wind, biomass, hydro, storage and conventional power plants.

## `energyTypes` (type: `array`):

Filter by energy source (electricity-generation only). Leave empty for all sources. Each selected source is fetched separately and merged.

## `states` (type: `array`):

Filter by German federal state. Leave empty for all of Germany. Each state is fetched separately and merged.

## `operationalStatus` (type: `array`):

Filter by status. Defaults to units that are currently in operation. Each status is fetched separately and merged.

## `cityPreset` (type: `string`):

Pick a German city / municipality to focus on. Leave empty to search all of Germany.

## `city` (type: `string`):

Optional: type an exact city / municipality name not in the dropdown above, e.g. "Freiburg im Breisgau". Overrides the dropdown when set. Leave empty to use the dropdown.

## `postalCode` (type: `string`):

Filter by exact German postal code, e.g. "10115".

## `operatorName` (type: `string`):

Filter by operator name (organisations only), e.g. "GmbH", "Solarpark", "Energie". Great for finding commercial operators for B2B leads.

## `onlyCommercial` (type: `boolean`):

Keep only units with a named (non-anonymised) operator — i.e. companies and organisations. Private individuals are anonymised by the registry.

## `minCapacityKw` (type: `integer`):

Keep only units with gross power (Bruttoleistung) at or above this value in kW.

## `maxCapacityKw` (type: `integer`):

Keep only units with gross power (Bruttoleistung) at or below this value in kW.

## `sortBy` (type: `string`):

Order in which units are fetched from the registry.

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

Maximum number of units to return across all filters. Set 0 for no limit. Tip: a run with no filters returns a fast mixed sample of the newest ~150 units — add filters and raise this to go deeper.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. A proxy is optional but recommended for large runs to keep them fast and reliable.

## Actor input object example

```json
{
  "unitCategory": "electricity-generation",
  "operationalStatus": [
    "in-operation"
  ],
  "cityPreset": "",
  "onlyCommercial": false,
  "sortBy": "newest",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `unitId` (type: `string`):

Internal registry unit ID

## `mastrNr` (type: `string`):

Official MaStR unit number

## `unitName` (type: `string`):

Display name of the unit

## `category` (type: `string`):

Registry category (electricity/gas generation/consumption)

## `energySource` (type: `string`):

Energy source (Solar, Wind, Biomass, ...)

## `status` (type: `string`):

Operational status

## `operatorName` (type: `string`):

Operator name (organisations; private individuals anonymised)

## `operatorMastrNr` (type: `string`):

Operator's MaStR number

## `isCommercial` (type: `string`):

True if the operator is a named organisation

## `grossPowerKw` (type: `string`):

Gross capacity in kW (Bruttoleistung)

## `netPowerKw` (type: `string`):

Net nominal capacity in kW (Nettonennleistung)

## `solarModuleCount` (type: `string`):

Number of solar modules (solar units)

## `commissioningDate` (type: `string`):

Date the unit went into operation

## `reportedDate` (type: `string`):

Date the unit was reported to the registry

## `lastUpdated` (type: `string`):

Last update date in the registry

## `city` (type: `string`):

City / municipality (Ort)

## `postalCode` (type: `string`):

Postal code (PLZ)

## `parcel` (type: `string`):

Cadastral parcel (Flurstück)

## `detailUrl` (type: `string`):

Public MaStR detail page URL

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "operationalStatus": [
        "in-operation"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/marktstammdatenregister-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 = {
    "operationalStatus": ["in-operation"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/marktstammdatenregister-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 '{
  "operationalStatus": [
    "in-operation"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/marktstammdatenregister-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Marktstammdatenregister (MaStR) Scraper — German Energy Units",
        "description": "Extract solar, wind, biomass, hydro & storage units from Germany's official MaStR energy registry. Filter by energy source, state, postal code, operator & status. Get operator names, capacity (kW), commissioning date & location for B2B leads and market research.",
        "version": "0.1",
        "x-build-id": "WNwf9sulhPIyr3n7v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~marktstammdatenregister-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-marktstammdatenregister-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/haketa~marktstammdatenregister-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-marktstammdatenregister-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/haketa~marktstammdatenregister-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-marktstammdatenregister-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": {
                    "unitCategory": {
                        "title": "Unit category",
                        "enum": [
                            "electricity-generation",
                            "electricity-consumption",
                            "gas-generation",
                            "gas-consumption"
                        ],
                        "type": "string",
                        "description": "Which part of the registry to scrape. Electricity generation covers solar, wind, biomass, hydro, storage and conventional power plants.",
                        "default": "electricity-generation"
                    },
                    "energyTypes": {
                        "title": "Energy sources",
                        "type": "array",
                        "description": "Filter by energy source (electricity-generation only). Leave empty for all sources. Each selected source is fetched separately and merged.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "solar",
                                "wind",
                                "biomass",
                                "hydro",
                                "storage",
                                "nuclear",
                                "hydrogen",
                                "geothermal",
                                "solarthermal",
                                "naturalgas",
                                "lignite",
                                "hardcoal",
                                "minegas",
                                "sewagegas",
                                "mineraloil",
                                "heat",
                                "othergases",
                                "nonbiogenicwaste"
                            ],
                            "enumTitles": [
                                "Solar",
                                "Wind",
                                "Biomass",
                                "Hydro (Wasser)",
                                "Storage (Speicher)",
                                "Nuclear (Kernenergie)",
                                "Hydrogen (Wasserstoff)",
                                "Geothermal",
                                "Solar thermal",
                                "Natural gas (Erdgas)",
                                "Lignite (Braunkohle)",
                                "Hard coal (Steinkohle)",
                                "Mine gas (Grubengas)",
                                "Sewage gas (Klärgas)",
                                "Mineral oil products",
                                "Heat (Wärme)",
                                "Other gases",
                                "Non-biogenic waste"
                            ]
                        }
                    },
                    "states": {
                        "title": "Federal states (Bundesland)",
                        "type": "array",
                        "description": "Filter by German federal state. Leave empty for all of Germany. Each state is fetched separately and merged.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "baden-wuerttemberg",
                                "bayern",
                                "berlin",
                                "brandenburg",
                                "bremen",
                                "hamburg",
                                "hessen",
                                "mecklenburg-vorpommern",
                                "niedersachsen",
                                "nordrhein-westfalen",
                                "rheinland-pfalz",
                                "saarland",
                                "sachsen",
                                "sachsen-anhalt",
                                "schleswig-holstein",
                                "thueringen"
                            ],
                            "enumTitles": [
                                "Baden-Württemberg",
                                "Bayern (Bavaria)",
                                "Berlin",
                                "Brandenburg",
                                "Bremen",
                                "Hamburg",
                                "Hessen (Hesse)",
                                "Mecklenburg-Vorpommern",
                                "Niedersachsen (Lower Saxony)",
                                "Nordrhein-Westfalen (NRW)",
                                "Rheinland-Pfalz",
                                "Saarland",
                                "Sachsen (Saxony)",
                                "Sachsen-Anhalt",
                                "Schleswig-Holstein",
                                "Thüringen (Thuringia)"
                            ]
                        }
                    },
                    "operationalStatus": {
                        "title": "Operational status",
                        "type": "array",
                        "description": "Filter by status. Defaults to units that are currently in operation. Each status is fetched separately and merged.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "in-operation",
                                "in-planning",
                                "temporarily-shut-down",
                                "permanently-shut-down"
                            ],
                            "enumTitles": [
                                "In operation (In Betrieb)",
                                "In planning (In Planung)",
                                "Temporarily shut down",
                                "Permanently shut down"
                            ]
                        },
                        "default": [
                            "in-operation"
                        ]
                    },
                    "cityPreset": {
                        "title": "City",
                        "enum": [
                            "",
                            "Berlin",
                            "Hamburg",
                            "München",
                            "Köln",
                            "Frankfurt am Main",
                            "Stuttgart",
                            "Düsseldorf",
                            "Leipzig",
                            "Dortmund",
                            "Essen",
                            "Bremen",
                            "Dresden",
                            "Hannover",
                            "Nürnberg",
                            "Duisburg",
                            "Bochum",
                            "Wuppertal",
                            "Bielefeld",
                            "Bonn",
                            "Münster",
                            "Mannheim",
                            "Karlsruhe",
                            "Augsburg",
                            "Wiesbaden"
                        ],
                        "type": "string",
                        "description": "Pick a German city / municipality to focus on. Leave empty to search all of Germany.",
                        "default": ""
                    },
                    "city": {
                        "title": "City — custom (advanced)",
                        "type": "string",
                        "description": "Optional: type an exact city / municipality name not in the dropdown above, e.g. \"Freiburg im Breisgau\". Overrides the dropdown when set. Leave empty to use the dropdown."
                    },
                    "postalCode": {
                        "title": "Postal code (PLZ)",
                        "type": "string",
                        "description": "Filter by exact German postal code, e.g. \"10115\"."
                    },
                    "operatorName": {
                        "title": "Operator name contains",
                        "type": "string",
                        "description": "Filter by operator name (organisations only), e.g. \"GmbH\", \"Solarpark\", \"Energie\". Great for finding commercial operators for B2B leads."
                    },
                    "onlyCommercial": {
                        "title": "Only commercial operators",
                        "type": "boolean",
                        "description": "Keep only units with a named (non-anonymised) operator — i.e. companies and organisations. Private individuals are anonymised by the registry.",
                        "default": false
                    },
                    "minCapacityKw": {
                        "title": "Min gross capacity (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only units with gross power (Bruttoleistung) at or above this value in kW."
                    },
                    "maxCapacityKw": {
                        "title": "Max gross capacity (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only units with gross power (Bruttoleistung) at or below this value in kW."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "newest",
                            "oldest",
                            "capacity-desc",
                            "commissioning-desc"
                        ],
                        "type": "string",
                        "description": "Order in which units are fetched from the registry.",
                        "default": "newest"
                    },
                    "maxItems": {
                        "title": "Max units",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of units to return across all filters. Set 0 for no limit. Tip: a run with no filters returns a fast mixed sample of the newest ~150 units — add filters and raise this to go deeper.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. A proxy is optional but recommended for large runs to keep them fast and reliable.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
