# 12go.asia Scraper - Train, Bus, Ferry, Flight Schedules (Asia) (`jungle_synthesizer/12go-asia-multimodal-scraper`) Actor

Scrape multimodal transport from 12go.asia: trains, buses, ferries, flights, vans, and private transfers across 40+ Asian countries. Returns operator, vehicle class, schedules, fares, ratings, and route metadata for travel apps and aggregators.

- **URL**: https://apify.com/jungle\_synthesizer/12go-asia-multimodal-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Travel, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## 12go.asia Multimodal Transport Scraper

Scrape multimodal transport schedules and fares from [12go.asia](https://12go.asia). Returns trains, buses, ferries, flights, vans, and private transfers across Thailand, Vietnam, Indonesia, Malaysia, Philippines, Cambodia, Laos, Japan, India, Sri Lanka, and 30+ other countries — with operator names, schedules, fares, ratings, and direct booking links in clean JSON.

---

### 12go Asia Scraper Features

- Extracts trip data across **all 12go transport modes** — train, bus, ferry, flight, van, private transfer, taxi, and mixed multi-segment journeys.
- Returns a flat record per scheduled trip with operator, vehicle class, departure and arrival times, duration, transfers, price, currency, rating, route distance, and a deep link back to the 12go search page.
- Searches by city pair — supply origin, destination, and an optional travel date. Slug resolution is automatic (e.g. `Koh Samui` becomes `koh-samui`, `Ho Chi Minh City` becomes `ho-chi-minh-city`).
- Currency override built in. Pick from USD, EUR, GBP, THB, VND, IDR, MYR, SGD, PHP, JPY, INR, or AUD and 12go converts at the listing currency.
- Multi-route batches in a single run — each search executes against a shared warmed session with deduplication, so the same trip never appears twice.
- Resilient session bootstrap. If a route page is briefly rate-limited, the scraper rotates the proxy session and retries automatically.
- Residential proxy support out of the box for stable runs.

---

### Who Uses 12go Asia Data?

- **Travel aggregators** — feed real-time schedules and fares into route-planning apps without negotiating partner agreements.
- **Backpacker booking platforms** — rebuild the 12go index with your own filtering and presentation, or pull in price comparisons.
- **Tourism startups in Southeast Asia** — track operator pricing, route popularity, and seat availability across the region's biggest multimodal booking engine.
- **Hostel and accommodation sites** — show transport options between properties as a value-add.
- **Travel-tech researchers** — analyze pricing trends, operator coverage, and route density across countries that don't surface this data anywhere else.
- **Affiliate marketers** — generate booking-link inventory for content sites and SEO landing pages.

---

### How 12go Asia Scraper Works

1. Provide a list of `{ origin, destination, date? }` searches. City names get lowercased and dashed into 12go's URL slugs.
2. The scraper warms a session against the 12go homepage to establish the cookies the site expects.
3. For each route, it fetches the rendered schedule page and parses the embedded payload — every departure 12go shows for that route on that date.
4. One record per scheduled trip is written to the dataset. Set `maxItems` to cap the total across all searches.

---

### Input

```json
{
    "searches": [
        { "origin": "Bangkok", "destination": "Koh Samui" },
        { "origin": "Ho Chi Minh City", "destination": "Phnom Penh", "date": "2026-08-15" }
    ],
    "currency": "USD",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searches` | array of objects | — (required) | List of routes. Each entry has `origin` (string), `destination` (string), and optional `date` (`YYYY-MM-DD`). |
| `currency` | string | `USD` | Output currency. One of: `USD`, `EUR`, `GBP`, `THB`, `VND`, `IDR`, `MYR`, `SGD`, `PHP`, `JPY`, `INR`, `AUD`. |
| `maxItems` | integer | `15` | Maximum total trip records across all searches. |
| `proxyConfiguration` | object | residential | Apify proxy configuration. Residential is recommended for stable runs. |

***

### 12go Asia Scraper Output Fields

```json
{
    "trip_id": "bangkok|koh_samui|flight|scoot|economy|00_25|07_50",
    "mode": "flight",
    "operator": "Scoot",
    "vehicle_class": "Economy",
    "origin_city": "Bangkok",
    "origin_terminal": "",
    "origin_country": "TH",
    "destination_city": "Koh Samui",
    "destination_terminal": "",
    "destination_country": "TH",
    "departure_time": "00:25",
    "arrival_time": "07:50",
    "travel_date": "2026-05-05",
    "duration_minutes": 445,
    "duration_text": "7h 25m",
    "transfers": 0,
    "distance_km": 971,
    "daily_route_count": 85,
    "operators_on_route": "Bangkok Airways | BangkokTaxi24 | Boonsiri High Speed Ferries | Lomprayah | Nok Air | Raja Ferry | Seatran Discovery | Thai AirAsia | Thai Lion Air | Thai Railways | Thai Vietjet | ...",
    "price_total": 267,
    "price_text": "EUR 267",
    "price_currency": "EUR",
    "rating": null,
    "booking_url": "https://12go.asia/en/travel/bangkok/koh-samui?date=2026-05-05&currency=USD",
    "scraped_at": "2026-05-02T11:53:28.482Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `trip_id` | string | Stable per-route synthesized ID (origin|dest|mode|operator|class|dep|arr). |
| `mode` | string | Transport mode: `train`, `bus`, `ferry`, `flight`, `van`, `private_transfer`, `taxi`, or `mixed` for multi-segment trips. |
| `operator` | string | Operator name (Lomprayah, State Railway of Thailand, Bangkok Airways, Giant Ibis, etc.). |
| `vehicle_class` | string | Vehicle class label (`VIP Van 9pax`, `Sleeper`, `Economy`, `Standard`, etc.). |
| `origin_city` | string | Origin city as supplied in the search. |
| `origin_terminal` | string | Departure terminal — usually empty in the schedule view. |
| `origin_country` | string | Origin country ISO 3166-1 alpha-2 code (`TH`, `VN`, `ID`, etc.). |
| `destination_city` | string | Destination city as supplied in the search. |
| `destination_terminal` | string | Arrival terminal — usually empty in the schedule view. |
| `destination_country` | string | Destination country ISO 3166-1 alpha-2 code. |
| `departure_time` | string | Scheduled departure as `HH:MM` (24-hour, local), or `Any time` for on-demand transfers. |
| `arrival_time` | string | Scheduled arrival as `HH:MM`, or `+Nh` when arrival is on the next day. |
| `travel_date` | string | Travel date in `YYYY-MM-DD` if supplied in the search; otherwise empty. |
| `duration_minutes` | number | Total duration in minutes (computed from departure/arrival; null when timing is non-numeric). |
| `duration_text` | string | Duration as a human-readable string (`14h`, `13h 30m`). |
| `transfers` | number | Number of connections. `0` for direct trips, `1` for mixed-mode rows. |
| `distance_km` | number | Route distance in kilometers (route-level). |
| `daily_route_count` | number | Total daily departures across all operators on this route. |
| `operators_on_route` | string | Pipe-separated list of every operator serving this route (route-level metadata). |
| `price_total` | number | Numeric total price in the listing currency. |
| `price_text` | string | Price as displayed (`THB 18750`, `EUR 267`). |
| `price_currency` | string | ISO currency code from 12go's price object. |
| `rating` | number | Operator/trip rating from 1 to 5. `null` when there are no reviews. |
| `booking_url` | string | Canonical 12go.asia search-page URL — deep link into the booking flow. |
| `scraped_at` | string | ISO 8601 timestamp of the scrape. |

***

### FAQ

#### How do I scrape 12go.asia transport data?

12go Asia Scraper handles it. Supply a list of city pairs in the `searches` input, and the scraper resolves them to 12go URL slugs, fetches each route's schedule page, parses the embedded data, and writes structured JSON to the dataset.

#### How much does the 12go Asia Scraper cost to run?

Pricing is pay-per-event: $0.10 per actor start, plus $0.001 per trip record. Most runs cost a few cents — a 50-trip search comes in around $0.15. Apify proxy usage is included in the per-record price.

#### What data can I get from 12go.asia?

Operator name, transport mode, vehicle class, departure and arrival times, duration in minutes, number of transfers, total price in your chosen currency, operator rating, route distance in kilometers, daily-departures count for the route, and a direct booking URL. Plus the full list of operators serving each route.

#### Does the 12go Asia Scraper need proxies?

Apify residential proxies are recommended and on by default. 12go is geo-aware, and a stable residential session keeps page fetches consistent across the run. You can switch to no proxy or datacenter via the `proxyConfiguration` input if your use case allows.

#### Can I get prices in a specific currency?

Yes. Set `currency` to any of `USD`, `EUR`, `GBP`, `THB`, `VND`, `IDR`, `MYR`, `SGD`, `PHP`, `JPY`, `INR`, or `AUD`. 12go converts in real time. The default is USD.

#### What countries does 12go cover?

Heavy coverage across Southeast Asia — Thailand, Vietnam, Indonesia, Malaysia, Philippines, Cambodia, Laos, Myanmar — plus growing service in Japan, India, Sri Lanka, Turkey, Egypt, Morocco, and more. Some EU routes are bundled via partner integrations.

***

### Need More Features?

Need extra fields, a different output format, or a related scraper? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use 12go Asia Scraper?

- **Affordable** — about $0.001 per trip record, with a $0.10 start fee.
- **Multimodal coverage** — train, bus, ferry, flight, van, and private transfer in a single actor — more than the source site's official partners offer in their own APIs.
- **Clean structured JSON** — flat records with parsed duration in minutes, ISO country codes, and direct booking links. No HTML cleanup on your end.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `searches` (type: `array`):

Each entry: { origin, destination, date (YYYY-MM-DD, optional) }. Origin and destination are city names — they get lowercased + dashed into 12go slugs (e.g. 'Bangkok' -> 'bangkok', 'Koh Samui' -> 'koh-samui').

## `currency` (type: `string`):

Currency for fares. 12go converts in real time.

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

Cap total trip records across all searches.

## `proxyConfiguration` (type: `object`):

Residential proxy is recommended — 12go sits behind AWS WAF; a stable residential session keeps the WAF clearance for the run.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "searches": [
    {
      "origin": "Bangkok",
      "destination": "Koh Samui"
    }
  ],
  "currency": "USD",
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "searches": [
        {
            "origin": "Bangkok",
            "destination": "Koh Samui"
        }
    ],
    "currency": "USD",
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/12go-asia-multimodal-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "searches": [{
            "origin": "Bangkok",
            "destination": "Koh Samui",
        }],
    "currency": "USD",
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/12go-asia-multimodal-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "searches": [
    {
      "origin": "Bangkok",
      "destination": "Koh Samui"
    }
  ],
  "currency": "USD",
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call jungle_synthesizer/12go-asia-multimodal-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "12go.asia Scraper - Train, Bus, Ferry, Flight Schedules (Asia)",
        "description": "Scrape multimodal transport from 12go.asia: trains, buses, ferries, flights, vans, and private transfers across 40+ Asian countries. Returns operator, vehicle class, schedules, fares, ratings, and route metadata for travel apps and aggregators.",
        "version": "1.0",
        "x-build-id": "IoQbgmOFgZMnh01NN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~12go-asia-multimodal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-12go-asia-multimodal-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/jungle_synthesizer~12go-asia-multimodal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-12go-asia-multimodal-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/jungle_synthesizer~12go-asia-multimodal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-12go-asia-multimodal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searches",
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "searches": {
                        "title": "Routes to Search",
                        "type": "array",
                        "description": "Each entry: { origin, destination, date (YYYY-MM-DD, optional) }. Origin and destination are city names — they get lowercased + dashed into 12go slugs (e.g. 'Bangkok' -> 'bangkok', 'Koh Samui' -> 'koh-samui')."
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "THB",
                            "VND",
                            "IDR",
                            "MYR",
                            "SGD",
                            "PHP",
                            "JPY",
                            "INR",
                            "AUD"
                        ],
                        "type": "string",
                        "description": "Currency for fares. 12go converts in real time.",
                        "default": "USD"
                    },
                    "maxItems": {
                        "title": "Max Trips",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap total trip records across all searches.",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended — 12go sits behind AWS WAF; a stable residential session keeps the WAF clearance for the run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
