# Busbud Bus & Train Fare Scraper (`crawlerbros/busbud-scraper`) Actor

Scrape Busbud bus and train departures between any two cities - operators, vehicle types, amenities, schedules, durations, and prices aggregated across 500+ operators.

- **URL**: https://apify.com/crawlerbros/busbud-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Busbud Bus & Train Fare Scraper

Scrape **Busbud** — the bus and train fare aggregator covering 500+ operators worldwide. Get individual scheduled departures between two cities: operator, vehicle type, on-board amenities, departure/arrival times and locations, trip duration, and price. HTTP-only, no login, no cookies required.

### What this actor does

- **Route search by city name** — free-text origin/destination, resolved automatically to Busbud's internal location codes
- **Batch mode** — supply an array of origin/destination pairs to scrape many routes in one run
- **Rolling ~8-day schedule window** — every run returns real scheduled departures for today through the next several days; filter to one exact date if needed
- **Filters:** travel date, vehicle type, operator name (substring match), max duration, max price
- **Sort:** recommended (site order), cheapest first, fastest first, earliest departure first
- **30 currencies** — every price re-quoted server-side in the currency you choose
- **Route-level context** on every record: cheapest/highest fare seen, daily departure count, distance
- **Empty fields are omitted** — a field only appears on a record when real data was found for it

### Output per departure

- `origin`, `destination` — canonical city names for the route
- `date` — the calendar date (YYYY-MM-DD) this departure runs
- `operator` — carrier name (e.g. `FlixBus`, `Greyhound Lines, Inc.`, `OurBus`)
- `vehicleType` — e.g. `bus`, `train`
- `amenities[]` — on-board amenities shown for this departure (e.g. `Wifi`, `Toilet`, `Power outlets`)
- `tags[]` — Busbud's own badges for this departure, e.g. `Cheapest`, `Fastest`
- `departureTime`, `departureDateTime`, `departureLocation`
- `arrivalTime`, `arrivalDateTime`, `arrivalLocation`
- `durationMinutes`, `durationText`
- `price`, `currency`
- `bookingLink` — deep link to book this specific departure on Busbud
- `routeLowPrice`, `routeHighPrice`, `routeDailyOfferCount` — route-level fare context
- `routeDistanceMiles`, `routeDistanceKm` — route-level distance
- `sourceUrl` — the Busbud route page this was scraped from
- `recordType: "departure"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `origin` | string | `Boston` | Starting city name. Ignored if `routePairs` is set. |
| `destination` | string | `New York City` | Ending city name. Ignored if `routePairs` is set. |
| `routePairs` | array | – | Batch mode: `[{"origin": "...", "destination": "..."}, ...]` |
| `date` | string | – | Keep only departures on this exact date (`YYYY-MM-DD`); leave blank for the full published window |
| `vehicleType` | string | `any` | `any` / `bus` / `train` / `shuttle` / `minibus` / `ferry` |
| `operatorName` | string | – | Keep only departures whose operator name contains this text (case-insensitive) |
| `maxDurationMinutes` | int | – | Drop departures longer than this many minutes |
| `maxPrice` | number | – | Drop departures priced above this amount (in the selected `currency`) |
| `currency` | string | `USD` | Re-price every departure in this currency (30 supported, e.g. `EUR`, `CAD`, `GBP`, `JPY`, `INR`) |
| `sortBy` | string | `recommended` | `recommended` / `cheapest` / `fastest` / `departureTime` |
| `maxItems` | int | `50` | Hard cap on emitted departures (1–1000) |
| `proxyConfiguration` | object | AUTO | Apify proxy (free AUTO datacenter group); not strictly required |

### Examples

#### Example: simple city-to-city search

```json
{
  "origin": "Boston",
  "destination": "New York City",
  "maxItems": 20
}
````

#### Example: one exact travel date, cheapest first

```json
{
  "origin": "Toronto",
  "destination": "Montreal",
  "date": "2026-07-10",
  "sortBy": "cheapest"
}
```

#### Example: only Greyhound buses under $50

```json
{
  "origin": "Chicago",
  "destination": "Milwaukee",
  "operatorName": "Greyhound",
  "maxPrice": 50
}
```

#### Example: fares in euros

```json
{
  "origin": "Paris",
  "destination": "Amsterdam",
  "currency": "EUR"
}
```

#### Example: batch multiple routes in one run

```json
{
  "routePairs": [
    { "origin": "Calgary", "destination": "Banff" },
    { "origin": "Montreal", "destination": "Quebec City" }
  ],
  "maxItems": 100
}
```

### Use cases

- **Travel booking comparison tools** — pull live bus/train fares into a fare-comparison UI
- **Price tracking** — snapshot fares for a route over time to spot trends
- **Travel content/SEO** — power "how to get from X to Y by bus" articles with real schedules
- **Corporate/group travel planning** — compare operators, amenities, and cost for a route
- **Market research** — see which operators actively service a given city pair

### Data Source / Limitations

Data comes from Busbud's public route pages, which publish a rolling schedule window (today through roughly the next 7 days) without requiring login. City names are resolved automatically through Busbud's own public location-suggestion service; ambiguous names (e.g. multiple cities sharing a name) are resolved to Busbud's best relevance match, with automatic fallback to nearby candidates (and a live check that a route page actually exists) if the top match turns out to have no service. Dates outside the published window, or route pairs Busbud has no service for, return 0 records with a clear status message rather than failing. `operatorName` is a substring filter rather than a fixed dropdown because Busbud aggregates 500+ operators — far more than a stable enum can cover.

For a small number of large cities, Busbud's public location-suggestion service doesn't surface a clean city-level match at all (only specific stations/landmarks) even though the city itself has real service — in that case the actor tries several fallback candidates before giving up, but may occasionally still report 0 results for a genuinely serviced city. Retrying with a nearby well-known landmark or the metro area's main station name in `origin`/`destination` works around this when it occurs.

### FAQ

**Is this affiliated with Busbud?**
No — this is an independent, third-party actor that reads Busbud's public route pages.

**Why do some departures have no `tags` field?**
Busbud only badges select departures as "Cheapest" or "Fastest" on a given route; most departures carry no badge, so the field is omitted for those.

**How far ahead can I search?**
Busbud's route pages publish roughly an 8-day rolling window starting today. Requesting a `date` further out than that returns 0 records for that request.

**What currency are prices in?**
Whatever you set in `currency` (defaults to `USD`). Busbud re-prices every fare on the page server-side in the requested currency — 30 currencies are supported.

**Why is `operatorName` a text filter instead of a dropdown?**
Busbud aggregates 500+ bus and train operators globally — far too many for a stable dropdown — so this field matches any operator name containing your text, case-insensitively.

**What happens if a city name doesn't resolve, or the route has no service?**
The actor returns 0 records and sets a status message explaining why — this is a clean, valid result, not an error.

# Actor input Schema

## `origin` (type: `string`):

Starting city name. Ignored if `routePairs` is provided.

## `destination` (type: `string`):

Ending city name. Ignored if `routePairs` is provided.

## `routePairs` (type: `array`):

Provide multiple {"origin": "...", "destination": "..."} pairs to scrape several routes in one run. When non-empty, this overrides the single `origin`/`destination` fields above.

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

Only keep departures on this date. Busbud publishes a rolling ~8-day schedule window starting today; dates outside that window return 0 results. Leave blank to keep every date in the published window.

## `vehicleType` (type: `string`):

Only keep departures using this vehicle type.

## `operatorName` (type: `string`):

Only keep departures whose operator name contains this text (case-insensitive). Examples: `Flixbus`, `Greyhound`, `Peter Pan`, `OurBus`, `Alsa`, `National Express`. Leave blank to keep every operator.

## `maxDurationMinutes` (type: `integer`):

Drop departures whose total travel time exceeds this many minutes.

## `maxPrice` (type: `number`):

Drop departures whose price exceeds this amount (in the selected `currency`).

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

Re-price every departure in this currency (Busbud's own currency switcher, applied server-side).

## `sortBy` (type: `string`):

How to order the emitted departures.

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

Hard cap on total departures emitted across all requested routes.

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

Uses Apify's free AUTO proxy group to reduce the chance of rate-limiting. Not strictly required.

## Actor input object example

```json
{
  "origin": "Boston",
  "destination": "New York City",
  "routePairs": [],
  "vehicleType": "any",
  "currency": "USD",
  "sortBy": "recommended",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `departures` (type: `string`):

Dataset containing all scraped Busbud departures.

# 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 = {
    "origin": "Boston",
    "destination": "New York City",
    "routePairs": [],
    "vehicleType": "any",
    "currency": "USD",
    "sortBy": "recommended",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/busbud-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 = {
    "origin": "Boston",
    "destination": "New York City",
    "routePairs": [],
    "vehicleType": "any",
    "currency": "USD",
    "sortBy": "recommended",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/busbud-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 '{
  "origin": "Boston",
  "destination": "New York City",
  "routePairs": [],
  "vehicleType": "any",
  "currency": "USD",
  "sortBy": "recommended",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/busbud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Busbud Bus & Train Fare Scraper",
        "description": "Scrape Busbud bus and train departures between any two cities - operators, vehicle types, amenities, schedules, durations, and prices aggregated across 500+ operators.",
        "version": "1.0",
        "x-build-id": "dhvb7NWldig1A3wRg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~busbud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-busbud-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/crawlerbros~busbud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-busbud-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/crawlerbros~busbud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-busbud-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": [
                    "origin",
                    "destination"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin city",
                        "type": "string",
                        "description": "Starting city name. Ignored if `routePairs` is provided.",
                        "default": "Boston"
                    },
                    "destination": {
                        "title": "Destination city",
                        "type": "string",
                        "description": "Ending city name. Ignored if `routePairs` is provided.",
                        "default": "New York City"
                    },
                    "routePairs": {
                        "title": "Batch route pairs (optional)",
                        "type": "array",
                        "description": "Provide multiple {\"origin\": \"...\", \"destination\": \"...\"} pairs to scrape several routes in one run. When non-empty, this overrides the single `origin`/`destination` fields above.",
                        "default": []
                    },
                    "date": {
                        "title": "Travel date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only keep departures on this date. Busbud publishes a rolling ~8-day schedule window starting today; dates outside that window return 0 results. Leave blank to keep every date in the published window."
                    },
                    "vehicleType": {
                        "title": "Vehicle type filter",
                        "enum": [
                            "any",
                            "bus",
                            "train",
                            "shuttle",
                            "minibus",
                            "ferry"
                        ],
                        "type": "string",
                        "description": "Only keep departures using this vehicle type.",
                        "default": "any"
                    },
                    "operatorName": {
                        "title": "Operator name filter",
                        "type": "string",
                        "description": "Only keep departures whose operator name contains this text (case-insensitive). Examples: `Flixbus`, `Greyhound`, `Peter Pan`, `OurBus`, `Alsa`, `National Express`. Leave blank to keep every operator."
                    },
                    "maxDurationMinutes": {
                        "title": "Max duration (minutes)",
                        "minimum": 1,
                        "maximum": 10080,
                        "type": "integer",
                        "description": "Drop departures whose total travel time exceeds this many minutes."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Drop departures whose price exceeds this amount (in the selected `currency`)."
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "CAD",
                            "EUR",
                            "GBP",
                            "AUD",
                            "NZD",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "ARS",
                            "BRL",
                            "CLP",
                            "COP",
                            "MXN",
                            "PEN",
                            "CNY",
                            "HKD",
                            "INR",
                            "ILS",
                            "JPY",
                            "KRW",
                            "SGD",
                            "THB",
                            "TRY",
                            "CZK",
                            "PLN",
                            "RUB",
                            "ZAR",
                            "MAD"
                        ],
                        "type": "string",
                        "description": "Re-price every departure in this currency (Busbud's own currency switcher, applied server-side).",
                        "default": "USD"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "recommended",
                            "cheapest",
                            "fastest",
                            "departureTime"
                        ],
                        "type": "string",
                        "description": "How to order the emitted departures.",
                        "default": "recommended"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on total departures emitted across all requested routes.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify's free AUTO proxy group to reduce the chance of rate-limiting. Not strictly required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```