# Energy-Charts Power Mix Scraper (`parseforge/energy-charts-power-mix-scraper`) Actor

Track the live electricity generation mix for Germany, France, Spain, and dozens more countries from the Fraunhofer ISE Energy Charts API. Returns country, ISO timestamp, unix time, production type such as solar, wind, nuclear, gas, and megawatt values. Great for grid research and graphs.

- **URL**: https://apify.com/parseforge/energy-charts-power-mix-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.63 / 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚡ Energy-Charts Power Mix Scraper

> 🚀 **Export a country's electricity generation mix in one run.** Pull 15 minute solar, wind, nuclear, gas, hydro, and load values straight from the Fraunhofer ISE Energy-Charts public API.

> 🕒 **Last updated:** 2026-06-08 · **📊 9 fields** per record · 30+ countries · 15 minute resolution

Turn the Fraunhofer ISE Energy-Charts data into clean, structured records you can drop into a dashboard, a forecasting model, or a research notebook. Pick a country and a date range and get one normalized record per timestamp and production type, with the value in megawatts.

Coverage spans Germany, France, Spain, Italy, and dozens more European countries plus the aggregated Europe view. Each day returns up to 96 time steps (15 minute intervals) across every production type the source reports, including solar, wind onshore and offshore, nuclear, fossil gas, brown and hard coal, hydro, biomass, cross border trading, and total load.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Energy analysts and traders | Track the daily generation mix per country |
| Grid and renewables researchers | Study solar and wind share over time |
| Data scientists and forecasters | Feed clean time series into models |
| Dashboard and app builders | Power a live energy mix visualization |

### 📋 What the Energy-Charts Power Mix Scraper does

This Actor calls the public Energy-Charts `public_power` endpoint and flattens its arrays into one clean record per time step and production type:

- **One record per (timestamp, production type)** so the data drops straight into a table or a chart.
- **Both unix and ISO time** on every record for easy joining and plotting.
- **Megawatt values** for each production type, including negative values where the source reports consumption (for example pumped storage).
- **Country and date range** echoed onto every record so multi country pulls stay self describing.

You control the country, the start and end date, and how many records come back. Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `country` | select | Which country or bidding zone to pull. One of `de`, `fr`, `es`, `it`, and 25+ more, or `all` for the aggregated Europe view. Defaults to `de`. |
| `start` | string | First day to include, formatted YYYY-MM-DD. Defaults to a recent day. |
| `end` | string | Last day to include, formatted YYYY-MM-DD. Use the same value as `start` for a single day. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — one day of German power mix**
```json
{
    "country": "de",
    "start": "2026-06-06",
    "end": "2026-06-06",
    "maxItems": 2016
}
````

**Example 2 — a sample of the French mix**

```json
{
    "country": "fr",
    "start": "2026-06-06",
    "end": "2026-06-06",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** A single day returns up to 96 time steps multiplied by the number of production types (around 19 to 21), so one country day is roughly 1,800 to 2,000 records. Records are ordered timestamp first, so a small `maxItems` gives you the earliest part of the day across every production type.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 🌍 `country` | Country code that was queried |
| 🕘 `isoTime` | Timestamp in ISO 8601 (UTC) |
| ⏱ `unixTimestamp` | Same timestamp as unix seconds |
| ⚡ `productionType` | Production type name (Solar, Wind onshore, Load, etc.) |
| 🔌 `valueMw` | Value in megawatts for that type at that time |
| 📅 `start` | Start date of the query |
| 📅 `end` | End date of the query |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — cross border trading**

```json
{
    "country": "de",
    "isoTime": "2026-06-05T22:00:00.000Z",
    "unixTimestamp": 1780696800,
    "productionType": "Cross border electricity trading",
    "valueMw": 10848.1,
    "start": "2026-06-06",
    "end": "2026-06-06",
    "scrapedAt": "2026-06-08T22:23:12.806Z",
    "error": null
}
```

**Real sample — hydro run of river**

```json
{
    "country": "de",
    "isoTime": "2026-06-05T22:00:00.000Z",
    "unixTimestamp": 1780696800,
    "productionType": "Hydro Run-of-River",
    "valueMw": 2279.9,
    "start": "2026-06-06",
    "end": "2026-06-06",
    "scrapedAt": "2026-06-08T22:23:12.827Z",
    "error": null
}
```

**Real sample — pumped storage consumption (negative)**

```json
{
    "country": "de",
    "isoTime": "2026-06-05T22:00:00.000Z",
    "unixTimestamp": 1780696800,
    "productionType": "Hydro pumped storage consumption",
    "valueMw": -12.3,
    "start": "2026-06-06",
    "end": "2026-06-06",
    "scrapedAt": "2026-06-08T22:23:12.748Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One normalized record per timestamp and production type, ready for a table or a chart.
- Both unix and ISO time on every record, so joins and plots are trivial.
- Negative values preserved for consumption types, so energy balances stay correct.
- No account, no key, and no login required.
- Stable field names that map cleanly onto a database schema.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Time series ready | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Reading charts by eye | Hours | No | No | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Energy-Charts Power Mix Scraper.
3. Choose a `country` and set a `start` and `end` date.
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Energy trading and analytics

| Goal | How this helps |
|---|---|
| Monitor the daily mix per country | Pull every production type at 15 minute resolution |
| Compare markets | Re-run across `de`, `fr`, `es`, and more |

#### Renewables research

| Goal | How this helps |
|---|---|
| Track solar and wind share | Filter the output to those production types |
| Study seasonal patterns | Snapshot the same day across a range of dates |

#### Forecasting and modeling

| Goal | How this helps |
|---|---|
| Train a load or generation model | Feed in clean unix indexed time series |
| Backtest a strategy | Pull historical days and replay them |

#### Dashboards and reporting

| Goal | How this helps |
|---|---|
| Power a live mix dashboard | Schedule runs and stream the records in |
| Build a weekly energy report | Aggregate by production type and day |

### 🔌 Automating Energy-Charts Power Mix Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how a national grid's generation mix shifts through the day.
- **Personal:** track when your country's grid is greenest.
- **Non-profit:** power a community climate or energy transparency project.
- **Experimentation:** prototype an energy app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to compute the renewable share, find the solar peak, or compare two countries on the same day.

### ❓ Frequently Asked Questions

**Do I need an Energy-Charts or Fraunhofer account?**
No. The Actor reads the public Energy-Charts API, which needs no login.

**Do I need an API key?**
No key is required.

**Which countries are supported?**
Germany, France, Spain, Italy, and around 30 European countries, plus an aggregated Europe (`all`) view. Pick one per run with the `country` input.

**What time resolution do I get?**
Most countries report 15 minute intervals, which is up to 96 time steps per day.

**Why are some values negative?**
Consumption oriented types such as pumped storage consumption and cross border trading can be negative. The Actor passes through what the source provides.

**What production types are included?**
Whatever the source reports for that country, typically Solar, Wind onshore, Wind offshore, Nuclear, Fossil gas, Fossil hard coal, Fossil brown coal, Hydro, Biomass, Load, and more.

**How many records is one day?**
Roughly 1,800 to 2,000 for a single country, since 96 time steps are multiplied by the number of production types.

**Can I pull more than one day?**
Yes. Set `end` later than `start` to span a range of days.

**How fresh is the data?**
Each run pulls live from Energy-Charts, so recent days reflect the latest published values.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the mix on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Energy-Charts or Fraunhofer ISE. Only publicly available data is collected.

# Actor input Schema

## `country` (type: `string`):

The country (or bidding zone) whose electricity generation mix you want. Backed by the Fraunhofer ISE Energy-Charts public\_power endpoint.

## `start` (type: `string`):

First day to include, formatted as YYYY-MM-DD (for example 2026-06-06). Defaults to a recent day.

## `end` (type: `string`):

Last day to include, formatted as YYYY-MM-DD. Use the same value as the start date for a single day.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "country": "de",
  "start": "2026-06-06",
  "end": "2026-06-06",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/energy-charts-power-mix-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/energy-charts-power-mix-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 '{
  "maxItems": 10
}' |
apify call parseforge/energy-charts-power-mix-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Energy-Charts Power Mix Scraper",
        "description": "Track the live electricity generation mix for Germany, France, Spain, and dozens more countries from the Fraunhofer ISE Energy Charts API. Returns country, ISO timestamp, unix time, production type such as solar, wind, nuclear, gas, and megawatt values. Great for grid research and graphs.",
        "version": "0.1",
        "x-build-id": "2gdEbPbx2jeDXqidt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~energy-charts-power-mix-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-energy-charts-power-mix-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/parseforge~energy-charts-power-mix-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-energy-charts-power-mix-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/parseforge~energy-charts-power-mix-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-energy-charts-power-mix-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",
                "required": [
                    "country"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pl",
                            "at",
                            "ch",
                            "be",
                            "cz",
                            "dk",
                            "fi",
                            "gr",
                            "hu",
                            "ie",
                            "no",
                            "pt",
                            "ro",
                            "rs",
                            "se",
                            "sk",
                            "si",
                            "bg",
                            "hr",
                            "ee",
                            "lt",
                            "lv",
                            "lu",
                            "me",
                            "mk",
                            "all"
                        ],
                        "type": "string",
                        "description": "The country (or bidding zone) whose electricity generation mix you want. Backed by the Fraunhofer ISE Energy-Charts public_power endpoint.",
                        "default": "de"
                    },
                    "start": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First day to include, formatted as YYYY-MM-DD (for example 2026-06-06). Defaults to a recent day.",
                        "default": "2026-06-06"
                    },
                    "end": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last day to include, formatted as YYYY-MM-DD. Use the same value as the start date for a single day.",
                        "default": "2026-06-06"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```