# OpenChargeMap EV Station Scraper (`parseforge/openchargemap-scraper`) Actor

Find EV charging stations from OpenChargeMap by coordinates or country. Each station returns its name, operator, address, status, connector types, maximum power in kW, and the number of charge points. Useful for trip planning, EV infrastructure research, and charging network analysis.

- **URL**: https://apify.com/parseforge/openchargemap-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 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.

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)

## ⚡ OpenChargeMap EV Station Scraper

> 🚀 **Map EV charging stations anywhere in seconds.** Query a city or a whole country and get operators, connector types, and power ratings for every station.

> 🕒 **Last updated:** 2026-06-02 · **📊 29 fields** per station · coordinate or country queries · global EV network

Pull electric vehicle charging stations from the OpenChargeMap global network. Search by coordinates with a radius or by country code, and for every station get its operator, full address, status, connector types, maximum power in kW, and the number of charge points.

**Coverage:** the worldwide OpenChargeMap database of public and private charging points. Pass coordinates (for example "51.5072,-0.1276") with a radius, or a two-letter country code.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| EV drivers and apps | Find and map nearby chargers |
| Charge network operators | Benchmark competitor coverage |
| Infrastructure analysts | Study connector and power mix |
| Fleet and logistics teams | Plan charging along routes |

### 📋 What the OpenChargeMap EV Station Scraper does

- Finds charging stations near coordinates or within a country.
- Returns 29 structured fields per station, including a full connector list.
- Captures operator, status, usage type, and verification date.
- Computes maximum power in kW and lists every connector type.
- Includes per-connector power, current type, and quantity.
- Exports to CSV, Excel, JSON, XML, or via API.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `coordinates` | string | Center point "lat,lon". Returns nearby stations. |
| `distanceKm` | integer | Search radius in km. |
| `countryCode` | string | Optional. Two-letter ISO code, used when no coordinates are given. |
| `maxItems` | integer | Cap on stations returned. Free plan is limited to 10. |
| `apiKey` | string | OpenChargeMap API key. A shared key is provided by default. |

**Example 1: by coordinates**
```json
{
  "coordinates": "51.5072,-0.1276",
  "distanceKm": 10,
  "maxItems": 100
}
````

**Example 2: by country**

```json
{
  "countryCode": "DE",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** OpenChargeMap requires a free API key. A shared key ships by default, but for heavy use get your own at openchargemap.org. The `distanceKm` field is populated only for coordinate queries. Some community records omit status, cost, or connector details, so those fields can be empty.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🆔 `stationId` | OpenChargeMap station ID |
| 🔑 `uuid` | Station UUID |
| ⚡ `title` | Station name |
| 🏢 `operator` | Charging network operator |
| 🚦 `usageType` | Public, private, membership, and similar |
| ✅ `status` | Operational status |
| 🏠 `addressLine1` | Street address |
| 🏙 `town` | Town or city |
| 🗺 `stateOrProvince` | State or province |
| 📮 `postcode` | Postal code |
| 🌍 `country` | Country name |
| 🏳 `countryCode` | Two-letter country code |
| 🧭 `latitude` | Latitude |
| 🧭 `longitude` | Longitude |
| 📏 `distanceKm` | Distance from the query point (coordinate queries) |
| ☎ `phone` | Contact phone |
| 🔗 `relatedUrl` | Operator or station URL |
| 💲 `usageCost` | Stated usage cost |
| 🔢 `numberOfPoints` | Reported charge points |
| #️⃣ `numberOfConnections` | Connector records |
| 🔌 `maxPowerKW` | Highest connector power in kW |
| 🔱 `connectionTypes` | Unique connector types |
| 📋 `connections` | Per-connector type, level, power, current, quantity |
| ☑ `isRecentlyVerified` | Recently verified flag |
| 🕒 `dateLastVerified` | Last verification timestamp |
| 🏷 `dataProvider` | Source data provider |
| 🔗 `stationUrl` | OpenChargeMap detail page |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "stationId": 104898,
  "title": "Saint Martins Lane Hotel",
  "operator": "BP Pulse (UK)",
  "usageType": "Public - Membership Required",
  "status": "Operational",
  "town": "45 Saint Martin's Lane",
  "country": "United Kingdom",
  "countryCode": "GB",
  "latitude": 51.510475,
  "longitude": -0.126729,
  "maxPowerKW": 50,
  "numberOfConnections": 3,
  "connectionTypes": ["CCS (Type 2)", "CHAdeMO", "Type 2 (Tethered Connector)"],
  "connections": [
    { "type": "CCS (Type 2)", "level": "Level 3: High (Over 40kW)", "powerKW": 50, "currentType": "DC", "quantity": 2 }
  ],
  "dateLastVerified": "2023-08-23T10:23:00Z",
  "stationUrl": "https://openchargemap.org/site/poi/details/104898",
  "error": null
}
```

```json
{
  "stationId": 490796,
  "title": "EnBW Ladestation",
  "operator": "EnBW (D)",
  "usageType": "Public",
  "status": "Operational",
  "town": "Piding",
  "country": "Germany",
  "countryCode": "DE",
  "latitude": 47.76536753088391,
  "longitude": 12.905386005739047,
  "maxPowerKW": 50,
  "numberOfConnections": 3,
  "connectionTypes": ["CCS (Type 2)", "CHAdeMO"],
  "connections": [
    { "type": "CCS (Type 2)", "level": "Level 3: High (Over 40kW)", "powerKW": 50, "currentType": "DC", "quantity": 1 }
  ],
  "dateLastVerified": "2026-05-27T09:19:00Z",
  "stationUrl": "https://openchargemap.org/site/poi/details/490796",
  "error": null
}
```

```json
{
  "stationId": 490074,
  "title": "Heidklift",
  "operator": "eCarUp (CH)",
  "usageType": "Public",
  "status": "Operational",
  "town": "Bedburg",
  "country": "Germany",
  "countryCode": "DE",
  "latitude": 51.002310300122275,
  "longitude": 6.538312400160976,
  "maxPowerKW": 50,
  "numberOfConnections": 1,
  "connectionTypes": ["CCS (Type 2)"],
  "connections": [
    { "type": "CCS (Type 2)", "level": "Level 3: High (Over 40kW)", "powerKW": 50, "currentType": "DC", "quantity": 1 }
  ],
  "dateLastVerified": "2026-05-27T06:38:00Z",
  "stationUrl": "https://openchargemap.org/site/poi/details/490074",
  "error": null
}
```

### ✨ Why choose this Actor

- **Global coverage.** Query any city by coordinates or any nation by code.
- **Connector detail.** Per-connector type, power, current, and quantity on every station.
- **Headline metrics.** Maximum power and unique connector types computed for you.
- **Operator and status.** Know who runs each station and whether it is operational.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a clean table view.

### 📈 How it compares to alternatives

| | OpenChargeMap EV Station Scraper | Manual API calls | Generic web scrapers |
|---|---|---|---|
| Per-connector detail | ✅ | ⚠️ Manual | ❌ |
| Coordinate and country search | ✅ | ⚠️ | ❌ |
| Computed max power and types | ✅ | ❌ | ❌ |
| Operator and status | ✅ | ⚠️ | ⚠️ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 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 OpenChargeMap EV Station Scraper.
3. Enter `coordinates` with a `distanceKm`, or a `countryCode`, and set `maxItems`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🗺 Network mapping**
| Goal | How |
|---|---|
| Map a city | Query coordinates with a radius |
| Cover a country | Query by country code |

**📊 Competitive analysis**
| Goal | How |
|---|---|
| Benchmark operators | Group stations by operator |
| Compare power | Sort by maximum kW |

**🚗 Route and fleet planning**
| Goal | How |
|---|---|
| Plan stops | Find fast chargers along a path |
| Match connectors | Filter by connector type |

**🏗 Infrastructure research**
| Goal | How |
|---|---|
| Study gaps | Aggregate stations by area |
| Track growth | Re-run on a schedule |

### 🔌 Automating OpenChargeMap EV Station Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Schedule runs and push fresh charging data into spreadsheets, databases, or alerts.

### 🌟 Beyond business use cases

- **Research:** study EV infrastructure growth across regions.
- **Personal:** find chargers near home or along a trip.
- **Non-profit:** support clean transport initiatives with open data.
- **Experimentation:** build EV analytics and mapping projects.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask for the fastest chargers, operator coverage, or connector distribution.

### ❓ Frequently Asked Questions

**1. Do I need an API key?**
OpenChargeMap requires a free key. A shared key ships by default, and you can add your own for heavy use.

**2. How do I search a city?**
Pass `coordinates` as "lat,lon" with a `distanceKm` radius.

**3. Can I search a whole country?**
Yes. Use `countryCode` with a two-letter ISO code.

**4. What connector data is included?**
Each station lists connector type, level, power in kW, current type, and quantity.

**5. Why is distance sometimes empty?**
Distance is calculated only for coordinate queries, not country queries.

**6. How fresh is the data?**
Each station shows `dateLastVerified` and an `isRecentlyVerified` flag.

**7. Can I filter by power or connector?**
Sort or filter the output by `maxPowerKW` or `connectionTypes` after a run.

**8. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push OpenChargeMap data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [PlugShare EV Charging Scraper](https://apify.com/parseforge/plugshare-scraper)
- [AFDC EV Stations Scraper](https://apify.com/parseforge/afdc-ev-stations-scraper)
- [OpenAQ Air Quality Scraper](https://apify.com/parseforge/openaq-air-quality-scraper)
- [EV Database Scraper](https://apify.com/parseforge/ev-database-scraper)
- [OpenStreetMap Nominatim Scraper](https://apify.com/parseforge/nominatim-osm-scraper)

> 💡 **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 OpenChargeMap. Data is provided by the OpenChargeMap open data platform and its contributors.

# Actor input Schema

## `coordinates` (type: `string`):

Center point as "latitude,longitude" (e.g. "51.5072,-0.1276"). Returns nearby charging stations. Takes priority over country.

## `distanceKm` (type: `integer`):

Search radius around the coordinates, in kilometers.

## `countryCode` (type: `string`):

Optional. Two-letter ISO country code (e.g. "US", "GB", "DE"). Used only when no coordinates are given.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## `apiKey` (type: `string`):

OpenChargeMap API key. A shared key is provided by default. For heavy use, get your own free key at openchargemap.org.

## Actor input object example

```json
{
  "coordinates": "51.5072,-0.1276",
  "distanceKm": 10,
  "maxItems": 10,
  "apiKey": "ff3a9388-daa1-41ae-9715-c1ac210f9398"
}
```

# 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 = {
    "coordinates": "51.5072,-0.1276",
    "distanceKm": 10,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/openchargemap-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 = {
    "coordinates": "51.5072,-0.1276",
    "distanceKm": 10,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openchargemap-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 '{
  "coordinates": "51.5072,-0.1276",
  "distanceKm": 10,
  "maxItems": 10
}' |
apify call parseforge/openchargemap-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenChargeMap EV Station Scraper",
        "description": "Find EV charging stations from OpenChargeMap by coordinates or country. Each station returns its name, operator, address, status, connector types, maximum power in kW, and the number of charge points. Useful for trip planning, EV infrastructure research, and charging network analysis.",
        "version": "0.1",
        "x-build-id": "gNqQVrjITY895V5Qu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openchargemap-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openchargemap-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~openchargemap-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openchargemap-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~openchargemap-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openchargemap-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": {
                    "coordinates": {
                        "title": "Coordinates (lat,lon)",
                        "type": "string",
                        "description": "Center point as \"latitude,longitude\" (e.g. \"51.5072,-0.1276\"). Returns nearby charging stations. Takes priority over country."
                    },
                    "distanceKm": {
                        "title": "Radius (km)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius around the coordinates, in kilometers."
                    },
                    "countryCode": {
                        "title": "Country code (ISO)",
                        "type": "string",
                        "description": "Optional. Two-letter ISO country code (e.g. \"US\", \"GB\", \"DE\"). Used only when no coordinates are given."
                    },
                    "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."
                    },
                    "apiKey": {
                        "title": "OpenChargeMap API key",
                        "type": "string",
                        "description": "OpenChargeMap API key. A shared key is provided by default. For heavy use, get your own free key at openchargemap.org.",
                        "default": "ff3a9388-daa1-41ae-9715-c1ac210f9398"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```