# Elering Nord Pool Electricity Prices Scraper (`parseforge/elering-nordpool-prices-scraper`) Actor

Track Nord Pool day ahead electricity spot prices across the Estonian, Finnish, Latvian, and Lithuanian bidding zones from the Elering dashboard. Each record carries the zone, ISO time, unix timestamp, and price in EUR per MWh. Handy for energy trading, billing models, and grid analytics.

- **URL**: https://apify.com/parseforge/elering-nordpool-prices-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **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)

## ⚡ Elering Nord Pool Electricity Prices Scraper

> 🚀 **Pull Baltic and Finnish day-ahead power prices in one run.** Get Nord Pool spot prices for Estonia, Finland, Latvia, and Lithuania straight from the public Elering dashboard, with no key or login.

> 🕒 **Last updated:** 2026-06-08 · **📊 8 fields** per record · 4 bidding zones · day-ahead spot market

Turn the Elering dashboard into a clean, structured price feed you can drop into a trading model, a billing engine, or an energy dashboard. Choose a date range and the bidding zones you care about, and get one tidy record per price point per zone with the timestamp and the price in EUR/MWh.

Coverage is the Nord Pool day-ahead spot market as Elering publishes it for the Baltic and Finnish bidding zones: Estonia (ee), Finland (fi), Latvia (lv), and Lithuania (lt). Elering reports prices for recent days and history at the resolution the market uses, currently 15 minute intervals, so a single day returns close to a hundred price points per zone.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Energy traders and analysts | Line up zone prices for spread and arbitrage analysis |
| Utilities and retailers | Feed billing and tariff models with spot prices |
| Smart home and EV developers | Schedule loads for the cheapest hours |
| Researchers and data teams | Study Baltic and Nordic power market behavior |

### 📋 What the Elering Nord Pool Prices Scraper does

This Actor calls the public Elering dashboard API and returns one clean record per price point for each bidding zone you request:

- **Zone** — the bidding zone code and a readable country name.
- **Time** — both an ISO timestamp and the raw unix timestamp for the price interval.
- **Price** — the Nord Pool day-ahead spot price in EUR/MWh, plus a convenience value in EUR/kWh.

You pick the date range, choose any mix of the four zones, and cap how many records come back. Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `start` | string | Start of the date range, inclusive. A date like `2026-06-06` or a full ISO timestamp. Defaults to the previous full day. |
| `end` | string | End of the date range, exclusive. A date like `2026-06-07` or a full ISO timestamp. Defaults to the start of the current day. |
| `zones` | array | Which bidding zones to include. Any of `ee`, `fi`, `lv`, `lt`. Empty means all four. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — one day, all four zones**
```json
{
    "start": "2026-06-06",
    "end": "2026-06-07",
    "zones": ["ee", "fi", "lv", "lt"],
    "maxItems": 400
}
````

**Example 2 — Estonia only, a single day**

```json
{
    "start": "2026-06-06",
    "end": "2026-06-07",
    "zones": ["ee"],
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Elering reports Nord Pool prices at the market resolution, currently 15 minute intervals, so one day returns roughly 97 price points per zone. Future hours appear only after the day-ahead auction clears, so a range that runs past the published horizon returns fewer points. Records are interleaved across the zones you request, so a small `maxItems` still gives you a balanced cross-zone sample.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 🌍 `zone` | Bidding zone code (`ee`, `fi`, `lv`, `lt`) |
| 🏳 `zoneName` | Readable country name |
| 🕰 `isoTime` | Price interval start as an ISO 8601 UTC timestamp |
| ⏱ `unixTimestamp` | Same interval as a unix timestamp in seconds |
| 💶 `priceEurMwh` | Nord Pool day-ahead spot price in EUR/MWh |
| 💡 `priceEurKwh` | Same price converted to EUR/kWh |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — Estonia**

```json
{
    "zone": "ee",
    "zoneName": "Estonia",
    "isoTime": "2026-06-06T00:00:00.000Z",
    "unixTimestamp": 1780704000,
    "priceEurMwh": 79.52,
    "priceEurKwh": 0.07952,
    "scrapedAt": "2026-06-08T22:05:57.643Z",
    "error": null
}
```

**Real sample — Finland**

```json
{
    "zone": "fi",
    "zoneName": "Finland",
    "isoTime": "2026-06-06T00:00:00.000Z",
    "unixTimestamp": 1780704000,
    "priceEurMwh": 79.41,
    "priceEurKwh": 0.07941,
    "scrapedAt": "2026-06-08T22:05:57.705Z",
    "error": null
}
```

**Real sample — Latvia**

```json
{
    "zone": "lv",
    "zoneName": "Latvia",
    "isoTime": "2026-06-06T00:15:00.000Z",
    "unixTimestamp": 1780704900,
    "priceEurMwh": 106.06,
    "priceEurKwh": 0.10606,
    "scrapedAt": "2026-06-08T22:05:58.080Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Four bidding zones in one run, all sharing the same clean record shape.
- Both ISO and unix timestamps, so the data slots into any tool without conversion.
- Prices in EUR/MWh and EUR/kWh, ready for trading or billing math.
- No account, no key, and no login required.
- Stable field names that map cleanly onto a database table.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Multi zone | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Copying from the dashboard by hand | Tedious | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | You build it | 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 Elering Nord Pool Electricity Prices Scraper.
3. Set the `start` and `end` dates for the range you want.
4. Choose the `zones` and set `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Energy trading and analytics

| Goal | How this helps |
|---|---|
| Compare prices across zones | Pull ee, fi, lv, and lt side by side |
| Build spread and arbitrage models | Use EUR/MWh values with aligned timestamps |

#### Utilities and retail supply

| Goal | How this helps |
|---|---|
| Feed billing and tariff models | Source spot prices per interval |
| Validate supplier invoices | Cross check charged rates against the market |

#### Smart home and demand response

| Goal | How this helps |
|---|---|
| Shift loads to cheap hours | Find the lowest priced intervals of the day |
| Schedule EV charging | Trigger charging when prices dip |

#### Research and reporting

| Goal | How this helps |
|---|---|
| Study Baltic and Nordic markets | Snapshot prices over chosen date ranges |
| Build energy dashboards | Drive charts with consistent records |

### 🔌 Automating Elering Nord Pool Prices Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route prices into sheets or databases.
- **Slack** to post a daily price 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 Baltic and Nordic spot prices move across zones and seasons.
- **Personal:** time your own appliance and EV usage to cheaper intervals.
- **Non-profit:** power a community energy awareness 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 find the cheapest hours, compare zones, or chart the daily price curve.

### ❓ Frequently Asked Questions

**Do I need an Elering or Nord Pool account?**
No. The Actor reads the public Elering dashboard API, which needs no login.

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

**Which zones can I pull?**
Estonia (ee), Finland (fi), Latvia (lv), and Lithuania (lt). Pick any mix with the `zones` input.

**What does the price represent?**
The Nord Pool day-ahead spot price for that bidding zone and interval, in EUR/MWh. A EUR/kWh value is included for convenience.

**Why are there so many records per day?**
Elering reports prices at the market resolution, currently 15 minute intervals, so a single day is roughly 97 points per zone.

**What time zone are the timestamps in?**
Times are UTC. `isoTime` is an ISO 8601 UTC string and `unixTimestamp` is the same moment in seconds.

**Can I get a range of several days?**
Yes. Set `start` and `end` to span the period you need, then raise `maxItems` accordingly.

**Why did I get fewer points than expected?**
The day-ahead auction publishes prices up to a horizon. Hours past that horizon are not available yet, so a forward range returns fewer points.

**How fresh is the data?**
Each run pulls live from Elering, so it reflects what the dashboard publishes at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot prices on any cadence, for example once a day after the auction clears.

### 🔌 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 Elering or Nord Pool. Only publicly available data is collected.

# Actor input Schema

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

Start of the date range, inclusive. Accepts a date like 2026-06-06 or a full ISO timestamp like 2026-06-06T00:00:00.000Z. Defaults to the start of the previous day if left empty.

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

End of the date range, exclusive. Accepts a date like 2026-06-07 or a full ISO timestamp. Defaults to the start of the current day if left empty.

## `zones` (type: `array`):

Which Nord Pool bidding zones to include. Estonia (ee), Finland (fi), Latvia (lv), Lithuania (lt). Leave empty to include all four.

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

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

## Actor input object example

```json
{
  "zones": [
    "ee",
    "fi",
    "lv",
    "lt"
  ],
  "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/elering-nordpool-prices-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/elering-nordpool-prices-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/elering-nordpool-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Elering Nord Pool Electricity Prices Scraper",
        "description": "Track Nord Pool day ahead electricity spot prices across the Estonian, Finnish, Latvian, and Lithuanian bidding zones from the Elering dashboard. Each record carries the zone, ISO time, unix timestamp, and price in EUR per MWh. Handy for energy trading, billing models, and grid analytics.",
        "version": "0.1",
        "x-build-id": "EDwcKmfbF7TLUehMe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~elering-nordpool-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-elering-nordpool-prices-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~elering-nordpool-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-elering-nordpool-prices-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~elering-nordpool-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-elering-nordpool-prices-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": {
                    "start": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Start of the date range, inclusive. Accepts a date like 2026-06-06 or a full ISO timestamp like 2026-06-06T00:00:00.000Z. Defaults to the start of the previous day if left empty."
                    },
                    "end": {
                        "title": "End date",
                        "type": "string",
                        "description": "End of the date range, exclusive. Accepts a date like 2026-06-07 or a full ISO timestamp. Defaults to the start of the current day if left empty."
                    },
                    "zones": {
                        "title": "Bidding zones",
                        "type": "array",
                        "description": "Which Nord Pool bidding zones to include. Estonia (ee), Finland (fi), Latvia (lv), Lithuania (lt). Leave empty to include all four.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ee",
                                "fi",
                                "lv",
                                "lt"
                            ],
                            "enumTitles": [
                                "Estonia (ee)",
                                "Finland (fi)",
                                "Latvia (lv)",
                                "Lithuania (lt)"
                            ]
                        },
                        "default": [
                            "ee",
                            "fi",
                            "lv",
                            "lt"
                        ]
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```