# Swiss Transit OpenData Scraper (`parseforge/swiss-transit-opendata-scraper`) Actor

Tap Swiss public transport data from transport.opendata.ch. Query journeys between two stations, live departure boards, or search stations by name. Returns stations, coordinates, departure and arrival times, platform, duration, transfers, and line. Useful for travel and route planning.

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

## Pricing

from $5.88 / 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)

## 🚆 Swiss Transit OpenData Scraper

> 🚀 **Export Swiss public transport data in seconds.** Pull journeys, live departure boards, and station search results straight from transport.opendata.ch.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 21 fields** per record · 3 query modes · nationwide Swiss coverage

Turn Swiss public transport into clean, structured records you can drop into a travel app, a route planner, a timetable widget, or a data pipeline. Pick one of three modes (connections, stationboard, or locations) and get departure and arrival times, platforms, durations, transfers, coordinates, and line details in a consistent shape.

Coverage is the full public transport network served by transport.opendata.ch: trains, trams, buses, boats, and cable cars across Switzerland. Search any station by name, plan a journey between two stops, or read the live departure board for a single station. No account and no API key are required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Travel and route planning apps | Plan journeys and show live departures |
| Mobility and logistics teams | Feed Swiss schedules into routing tools |
| Data analysts and researchers | Study connections, transfers, and delays |
| Hobbyists and bot builders | Build a departure board or trip notifier |

### 📋 What the Swiss Transit OpenData Scraper does

This Actor calls the public transport.opendata.ch API and returns one clean record per item for the mode you choose:

- **Connections** — journeys between a `from` and a `to` station, with departure and arrival times, platforms, duration, transfer count, products, and the first leg's line and operator.
- **Stationboard** — upcoming departures from a single station, with destination, departure time, delay, platform, category, and line.
- **Locations** — station search by name, returning matched station names, IDs, coordinates, and icon type.

Every record carries a `recordType` so you can tell the modes apart, plus a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | What to query. One of `connections`, `stationboard`, or `locations`. Defaults to `connections`. |
| `from` | string | Connections mode only. Departure station name, e.g. `Zurich`. |
| `to` | string | Connections mode only. Destination station name, e.g. `Bern`. |
| `station` | string | Stationboard mode only. Station whose departures you want, e.g. `Zurich HB`. |
| `query` | string | Locations mode only. Partial or full station name to search, e.g. `Luzern`. |
| `date` | string | Optional. Date in `YYYY-MM-DD` for connections or departures. Defaults to today. |
| `time` | string | Optional. Time in 24-hour `HH:MM` for connections or departures. Defaults to now. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — journey from Zurich to Bern**
```json
{
    "mode": "connections",
    "from": "Zurich",
    "to": "Bern",
    "maxItems": 10
}
````

**Example 2 — live departures from Basel SBB**

```json
{
    "mode": "stationboard",
    "station": "Basel SBB",
    "maxItems": 20
}
```

> ⚠️ **Good to Know:** Each mode uses a different set of inputs. Connections needs `from` and `to`, stationboard needs `station`, and locations needs `query`. The output fields also differ by mode, so use the `recordType` field to branch your logic.

### 📊 Output

Fields shared and mode-specific records are described below. Common fields appear in every record.

| Field | Description |
|---|---|
| 🧭 `recordType` | Record kind: `connection`, `departure`, or `location` |
| 🚉 `fromStation` | Origin (or matched/board) station name |
| 🆔 `fromStationId` | Origin station ID |
| 📍 `fromLat` | Origin latitude |
| 📍 `fromLon` | Origin longitude |
| 🏁 `toStation` | Destination station name |
| 🆔 `toStationId` | Destination station ID (connections) |
| 📍 `toLat` | Destination latitude (connections) |
| 📍 `toLon` | Destination longitude (connections) |
| 🕐 `departure` | Departure time (ISO) |
| ⏲ `departureTimestamp` | Departure UNIX timestamp |
| 🕑 `arrival` | Arrival time (connections) |
| ⏲ `arrivalTimestamp` | Arrival UNIX timestamp (connections) |
| 🛤 `platform` | Departure platform |
| 🛤 `arrivalPlatform` | Arrival platform (connections) |
| ⏱ `duration` | Journey duration (connections) |
| 🔁 `transfers` | Number of transfers (connections) |
| 🚆 `products` | Lines used on the journey (connections) |
| ⏳ `delay` | Departure delay in minutes (departures) |
| 🏷 `category` | Transport category, e.g. `IC`, `S`, `B` |
| #️⃣ `lineNumber` | Line number |
| 🏢 `operator` | Operating company |
| 🎯 `headsign` | Direction/headsign of the first leg (connections) |
| 🪧 `name` | Service name (departures) |
| 🖼 `icon` | Station icon type (locations) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — connection**

```json
{
    "recordType": "connection",
    "fromStation": "Zürich HB",
    "fromStationId": "8503000",
    "fromLat": 47.377847,
    "fromLon": 8.540502,
    "toStation": "Bern",
    "toStationId": "8507000",
    "toLat": 46.948832,
    "toLon": 7.439136,
    "departure": "2026-06-08T18:02:00+0200",
    "departureTimestamp": 1781280120,
    "arrival": "2026-06-08T19:00:00+0200",
    "arrivalTimestamp": 1781283600,
    "platform": "31",
    "arrivalPlatform": "6",
    "duration": "00d00:58:00",
    "transfers": 0,
    "products": ["IC 1"],
    "category": "IC",
    "lineNumber": "1",
    "operator": "SBB",
    "headsign": "Genève-Aéroport",
    "scrapedAt": "2026-06-08T16:00:00.000Z",
    "error": null
}
```

**Real sample — departure**

```json
{
    "recordType": "departure",
    "fromStation": "Basel SBB",
    "fromStationId": "8500010",
    "fromLat": 47.547412,
    "fromLon": 7.589563,
    "toStation": "Zürich HB",
    "departure": "2026-06-08T18:04:00+0200",
    "departureTimestamp": 1781280240,
    "delay": 0,
    "platform": "8",
    "category": "IC",
    "lineNumber": "3",
    "operator": "SBB",
    "name": "IC 3",
    "scrapedAt": "2026-06-08T16:00:00.000Z",
    "error": null
}
```

**Real sample — location**

```json
{
    "recordType": "location",
    "fromStation": "Luzern",
    "fromStationId": "8505000",
    "fromLat": 47.050168,
    "fromLon": 8.310015,
    "icon": "train",
    "scrapedAt": "2026-06-08T16:00:00.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per item, with a `recordType` flag so all three modes share a consistent table.
- Coordinates included on every station, ready for mapping.
- Departure and arrival times come as both ISO strings and UNIX timestamps.
- No transit account, no key, and no login required.
- Stable field names that map cleanly onto a database schema.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Coordinates included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Copying from a timetable site | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Swiss Transit OpenData Scraper.
3. Choose a `mode` (connections, stationboard, or locations).
4. Fill the inputs for that mode and set `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Travel and route planning

| Goal | How this helps |
|---|---|
| Show journeys between two stations | Use connections mode with times and transfers |
| Display a live departure board | Use stationboard mode with delays and platforms |

#### Mobility and logistics

| Goal | How this helps |
|---|---|
| Feed Swiss schedules into routing | Pull connections with line and operator data |
| Map station locations | Use the coordinate fields on every record |

#### Analytics and research

| Goal | How this helps |
|---|---|
| Study transfer patterns | Group connections by transfer count and products |
| Track delays over time | Snapshot stationboard departures on a schedule |

#### Apps and bots

| Goal | How this helps |
|---|---|
| Build a trip notifier | Poll connections for a route and alert on changes |
| Power a station lookup | Use locations mode for autocomplete |

### 🔌 Automating Swiss Transit OpenData Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a departure 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 Swiss transit connectivity and transfer patterns.
- **Personal:** build your own commuter departure board.
- **Non-profit:** power a community mobility resource.
- **Experimentation:** prototype a travel 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 compare routes, summarize departures, or find the fastest connection.

### ❓ Frequently Asked Questions

**Do I need a transport.opendata.ch account?**
No. The Actor reads the public API, which needs no login.

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

**Which modes can I use?**
Connections, stationboard, and locations. Pick one per run with the `mode` input.

**Which inputs does each mode need?**
Connections needs `from` and `to`, stationboard needs `station`, and locations needs `query`.

**Can I query a specific date and time?**
Yes. Use the optional `date` (YYYY-MM-DD) and `time` (HH:MM) inputs for connections and stationboard.

**Are coordinates included?**
Yes. Every station record carries latitude and longitude fields.

**Why do output fields differ between records?**
Each mode returns a different set of fields. Use the `recordType` field to branch your logic.

**What transport types are covered?**
Trains, trams, buses, boats, and cable cars across the Swiss network.

**How fresh is the data?**
Each run pulls live from transport.opendata.ch, so departures and delays reflect run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot routes or departures on any cadence.

### 🔌 Integrate with any app

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

### 🔗 Recommended Actors

- [FAA NAS Airport Status Scraper](https://apify.com/parseforge)
- [GDACS Disaster Alerts Scraper](https://apify.com/parseforge)
- More travel and reference 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 transport.opendata.ch or the Swiss transport operators. Only publicly available data is collected.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from transport.opendata.ch. 'Connections' returns journeys between two stations. 'Stationboard' returns upcoming departures from one station. 'Locations' searches for stations by name.

## `from` (type: `string`):

Only used when Mode is 'Connections'. The departure station name, for example 'Zurich' or 'Geneve'.

## `to` (type: `string`):

Only used when Mode is 'Connections'. The destination station name, for example 'Bern' or 'Lausanne'.

## `station` (type: `string`):

Only used when Mode is 'Stationboard'. The station whose departures you want, for example 'Zurich HB' or 'Basel SBB'.

## `query` (type: `string`):

Only used when Mode is 'Locations'. A partial or full station name to search for, for example 'Bern' or 'Luzern'.

## `date` (type: `string`):

Optional. Date for connections or departures in YYYY-MM-DD format, for example '2026-06-08'. Defaults to today.

## `time` (type: `string`):

Optional. Time for connections or departures in 24-hour HH:MM format, for example '08:30'. Defaults to now.

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

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

## Actor input object example

```json
{
  "mode": "connections",
  "from": "Zurich",
  "to": "Bern",
  "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 = {
    "from": "Zurich",
    "to": "Bern",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/swiss-transit-opendata-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 = {
    "from": "Zurich",
    "to": "Bern",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/swiss-transit-opendata-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 '{
  "from": "Zurich",
  "to": "Bern",
  "maxItems": 10
}' |
apify call parseforge/swiss-transit-opendata-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiss Transit OpenData Scraper",
        "description": "Tap Swiss public transport data from transport.opendata.ch. Query journeys between two stations, live departure boards, or search stations by name. Returns stations, coordinates, departure and arrival times, platform, duration, transfers, and line. Useful for travel and route planning.",
        "version": "0.1",
        "x-build-id": "w1kOatNVpQhkFbkYc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~swiss-transit-opendata-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-swiss-transit-opendata-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~swiss-transit-opendata-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-swiss-transit-opendata-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~swiss-transit-opendata-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-swiss-transit-opendata-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "connections",
                            "stationboard",
                            "locations"
                        ],
                        "type": "string",
                        "description": "What to fetch from transport.opendata.ch. 'Connections' returns journeys between two stations. 'Stationboard' returns upcoming departures from one station. 'Locations' searches for stations by name.",
                        "default": "connections"
                    },
                    "from": {
                        "title": "From station",
                        "type": "string",
                        "description": "Only used when Mode is 'Connections'. The departure station name, for example 'Zurich' or 'Geneve'."
                    },
                    "to": {
                        "title": "To station",
                        "type": "string",
                        "description": "Only used when Mode is 'Connections'. The destination station name, for example 'Bern' or 'Lausanne'."
                    },
                    "station": {
                        "title": "Station",
                        "type": "string",
                        "description": "Only used when Mode is 'Stationboard'. The station whose departures you want, for example 'Zurich HB' or 'Basel SBB'."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Only used when Mode is 'Locations'. A partial or full station name to search for, for example 'Bern' or 'Luzern'."
                    },
                    "date": {
                        "title": "Date",
                        "type": "string",
                        "description": "Optional. Date for connections or departures in YYYY-MM-DD format, for example '2026-06-08'. Defaults to today."
                    },
                    "time": {
                        "title": "Time",
                        "type": "string",
                        "description": "Optional. Time for connections or departures in 24-hour HH:MM format, for example '08:30'. Defaults to now."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```