# US EV Charger Area Monitor (`trovevault/us-ev-charger-area-monitor`) Actor

Monitors US EV charging stations by state, city, ZIP, network, pricing, connectors, and status. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/us-ev-charger-area-monitor.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Travel, Other, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 stations

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

## US EV Charger Area Monitor

Monitor EV charging stations by US state, city, or ZIP code. The actor returns station coverage, network, connector mix, public/private access type, access rules, visible pricing text, parsed price signals, and operational status fields from the Alternative Fuels Data Center station dataset.

Use it to build recurring EV charging coverage snapshots for fleet planning, charging app data QA, site host benchmarking, and regional infrastructure research. Schedule it daily, weekly, or before route reviews to see what charging options exist in an operating area and which records carry pricing, access, or reliability warnings.

### Why Use This Actor?

Fleet and site teams rarely need a raw map pin dump. They need a repeatable area report that can be exported, compared, monitored, and joined with internal routing or site data.

| Need | Basic map search | US EV Charger Area Monitor |
|---|---|---|
| Area input | Manual map panning | State, city, or ZIP input |
| Repeatability | Hard to automate | Schedule as an Apify run |
| Pricing | Often hidden in UI | Exports public pricing text and parsed signals |
| Status | Visual only | Normalized status and warning fields |
| BI use | Manual copy | JSON, CSV, Excel, API |
| Monitoring | No run history | Append to datasets across runs |

### Use Cases

#### Fleet route and depot planning
Find public charging stations in a state, city, or ZIP territory before assigning EV routes. Compare connector coverage, DC fast availability, access restrictions, and pricing visibility.

#### Charging reliability monitoring
Schedule recurring runs for target areas and track records marked as temporarily unavailable, restricted, stale, planned, or missing port counts. Use the output as an early warning layer for operational reviews.

#### Charging app data QA
Compare a charging app's local station coverage against public AFDC records. The actor gives stable station IDs, network labels, connector fields, and source timestamps for reconciliation.

#### Site host and network benchmarking
Monitor which charging networks appear in a region, what connector mix they expose, and whether pricing is visible enough for drivers and fleet planners.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `states` | Array | required | One or more US state or territory abbreviations, such as `CA`, `TX`, `NY`, or `FL` |
| `city` | String | optional | Narrow results to one city inside the selected state |
| `zipCodes` | Array | optional | Narrow results to one or more ZIP codes |
| `maxStations` | Number | 250 | Maximum station rows to return across the run |
| `includePlannedStations` | Boolean | false | Include planned stations in addition to existing and temporarily unavailable stations |
| `accessTypes` | Array | public | Include public stations, private stations, or both |
| `connectorTypes` | Array | optional | Filter to connector types such as `J1772`, `TESLA`, `J1772COMBO`, or `CHADEMO` |
| `datasetId` | String | optional | Existing Apify dataset ID to append results to |
| `runId` | String | optional | Parent run ID copied into every output row |

Example city run:

```json
{
  "states": ["CA"],
  "city": "Los Angeles",
  "maxStations": 250,
  "accessTypes": ["public"],
  "includePlannedStations": false
}
````

Example statewide DC fast run:

```json
{
  "states": ["TX"],
  "connectorTypes": ["J1772COMBO", "TESLA"],
  "maxStations": 2000
}
```

### Output

The actor returns one row per station observation.

| Field | Description |
|---|---|
| `areaLabel` | Requested area such as `Los Angeles, CA` or `TX` |
| `stationId` | AFDC station identifier |
| `stationName` | Public station name |
| `network` | EV charging network when provided |
| `sourceUrl` | AFDC station detail URL |
| `status` | Normalized source status |
| `availabilitySignal` | Operational signal derived from status and access |
| `pricingText` | Visible public EV pricing text |
| `priceAmount` | First parsed simple price amount when detected |
| `priceCurrency` | Parsed or inferred currency |
| `priceUnit` | Parsed unit such as `kWh`, `hour`, `session`, or `parking` |
| `pricingConfidence` | `missing`, `low`, `medium`, or `high` |
| `address`, `city`, `state`, `zip` | Location fields |
| `latitude`, `longitude` | Station coordinates from the public record |
| `accessType` | Normalized `public` or `private` value |
| `access`, `accessHours`, `restrictedAccess` | Public access fields |
| `connectorTypes` | Connector type list |
| `level1Ports`, `level2Ports`, `dcFastPorts`, `totalPorts` | Port counts from public fields |
| `lastConfirmedAt`, `updatedAt`, `observedAt` | Source and run timestamps |
| `warnings` | Compact warnings for missing or ambiguous fields |

Example row:

```json
{
  "areaLabel": "Los Angeles, CA",
  "stationId": 1523,
  "stationName": "City Hall Garage",
  "network": "ChargePoint Network",
  "sourceUrl": "https://afdc.energy.gov/fuels/electricity-locations#/station/1523",
  "status": "Available",
  "availabilitySignal": "operational_public_record",
  "pricingText": "$0.35 per kWh",
  "priceAmount": 0.35,
  "priceCurrency": "USD",
  "priceUnit": "kWh",
  "pricingConfidence": "medium",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90012",
  "accessType": "public",
  "connectorTypes": ["J1772COMBO"],
  "level2Ports": 0,
  "dcFastPorts": 4,
  "totalPorts": 4,
  "observedAt": "2026-05-31T10:00:00.000Z",
  "warnings": []
}
```

### API

Run from scripts, scheduled jobs, or monitoring pipelines with your Apify API token.

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~us-ev-charger-area-monitor/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states":["CA"],"city":"Los Angeles","maxStations":250}'
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('trovevault~us-ev-charger-area-monitor').call({
    states: ['CA'],
    city: 'Los Angeles',
    maxStations: 250,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Data Semantics

This actor reports station records observed during the run. It does not guarantee live plug-by-plug occupancy. Fields such as `status`, `pricingText`, `accessType`, `lastConfirmedAt`, and `updatedAt` come from AFDC station data. Use `observedAt` to compare runs over time.

Pricing is intentionally conservative. `pricingText` is the source text. `priceAmount`, `priceCurrency`, and `priceUnit` are parsed only when the text contains a simple recognizable pattern. Ambiguous pricing keeps the original text and adds a warning rather than pretending exact structure.

### Troubleshooting

**No stations returned**
Check the state abbreviation, remove the city or ZIP filter, and raise `maxStations`.

**Pricing is null**
Many station records do not publish pricing. Use `pricingText`, `pricingConfidence`, and `warnings` to separate missing pricing from parsed pricing.

**The status is not live occupancy**
The actor exposes public station status records, not real-time connector occupancy. Treat the output as an area monitoring and reliability signal, not a live navigation feed.

**Too many rows**
Lower `maxStations`, add a city, or add ZIP codes for depot-level monitoring.

### Limitations

The v1 actor is US-first. It is built on public AFDC station data and does not claim worldwide coverage, private app-only data, or guaranteed real-time availability. Future versions can add network-specific adapters, route corridors, or global registry coverage when those sources provide reliable station-level fields.

# Actor input Schema

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

One or more US state abbreviations. The actor returns public EV charging stations in those states and can be narrowed by city or ZIP code.

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

Optional city filter. Use this when a fleet, depot, or site team only needs stations inside one city within the selected state.

## `zipCodes` (type: `array`):

Optional ZIP codes to monitor. Leave blank for state or city coverage. Use ZIP codes for depot territories, route planning, and localized reliability checks.

## `maxStations` (type: `integer`):

Maximum stations to return across the full run. Set 100 for a quick city check, 1000 for a larger state sample, or higher for full state coverage.

## `includePlannedStations` (type: `boolean`):

Include planned or not-yet-open stations when available. Leave disabled for operational monitoring focused on chargers drivers can use now.

## `accessTypes` (type: `array`):

Choose whether to include public stations, private stations, or both. Public stations are useful for driver-facing route planning. Private stations are useful for infrastructure mapping, fleet depots, workplace charging, and site-host research.

## `connectorTypes` (type: `array`):

Optional connector filters such as J1772, TESLA, J1772COMBO, or CHADEMO. Leave blank to include all connector types.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append station observations to, in addition to the default run dataset.

## `runId` (type: `string`):

ID of a parent actor run to copy into each output row for pipeline traceability.

## Actor input object example

```json
{
  "states": [
    "CA"
  ],
  "zipCodes": [],
  "maxStations": 250,
  "includePlannedStations": false,
  "accessTypes": [
    "public"
  ],
  "connectorTypes": []
}
```

# Actor output Schema

## `dataset` (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 = {
    "states": [
        "CA"
    ],
    "zipCodes": [],
    "accessTypes": [
        "public"
    ],
    "connectorTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/us-ev-charger-area-monitor").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 = {
    "states": ["CA"],
    "zipCodes": [],
    "accessTypes": ["public"],
    "connectorTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/us-ev-charger-area-monitor").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 '{
  "states": [
    "CA"
  ],
  "zipCodes": [],
  "accessTypes": [
    "public"
  ],
  "connectorTypes": []
}' |
apify call trovevault/us-ev-charger-area-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/us-ev-charger-area-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US EV Charger Area Monitor",
        "description": "Monitors US EV charging stations by state, city, ZIP, network, pricing, connectors, and status. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "n05Srq49jAakNJ3KU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~us-ev-charger-area-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-us-ev-charger-area-monitor",
                "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/trovevault~us-ev-charger-area-monitor/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-us-ev-charger-area-monitor",
                "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/trovevault~us-ev-charger-area-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-us-ev-charger-area-monitor",
                "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": [
                    "states"
                ],
                "properties": {
                    "states": {
                        "title": "US States",
                        "type": "array",
                        "description": "One or more US state abbreviations. The actor returns public EV charging stations in those states and can be narrowed by city or ZIP code.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City (optional)",
                        "type": "string",
                        "description": "Optional city filter. Use this when a fleet, depot, or site team only needs stations inside one city within the selected state."
                    },
                    "zipCodes": {
                        "title": "ZIP Codes (optional)",
                        "type": "array",
                        "description": "Optional ZIP codes to monitor. Leave blank for state or city coverage. Use ZIP codes for depot territories, route planning, and localized reliability checks.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxStations": {
                        "title": "Max Stations",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum stations to return across the full run. Set 100 for a quick city check, 1000 for a larger state sample, or higher for full state coverage.",
                        "default": 250
                    },
                    "includePlannedStations": {
                        "title": "Include Planned Stations",
                        "type": "boolean",
                        "description": "Include planned or not-yet-open stations when available. Leave disabled for operational monitoring focused on chargers drivers can use now.",
                        "default": false
                    },
                    "accessTypes": {
                        "title": "Access Types",
                        "type": "array",
                        "description": "Choose whether to include public stations, private stations, or both. Public stations are useful for driver-facing route planning. Private stations are useful for infrastructure mapping, fleet depots, workplace charging, and site-host research.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "public",
                                "private"
                            ],
                            "enumTitles": [
                                "Public",
                                "Private"
                            ]
                        }
                    },
                    "connectorTypes": {
                        "title": "Connector Types (optional)",
                        "type": "array",
                        "description": "Optional connector filters such as J1772, TESLA, J1772COMBO, or CHADEMO. Leave blank to include all connector types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append station observations to, in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of a parent actor run to copy into each output row for pipeline traceability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```