# FlixBus Trip Prices Scraper (`automation-lab/flixbus-trip-prices-scraper`) Actor

Monitor FlixBus route fares, schedules, station names, durations, availability, and booking URLs for date-based bus price tracking.

- **URL**: https://apify.com/automation-lab/flixbus-trip-prices-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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

## FlixBus Trip Prices Scraper

Scrape FlixBus route prices, departures, durations, station names, availability signals, and booking URLs from public FlixBus route searches.

Use this actor when you need repeatable fare monitoring for intercity bus routes without opening the FlixBus website manually every day.

---

### What does FlixBus Trip Prices Scraper do?

FlixBus Trip Prices Scraper searches public FlixBus route/date combinations and returns structured trip price records.

It can resolve city IDs from public route pages such as `https://global.flixbus.com/bus-routes/bus-paris-lyon`.

It can also accept FlixBus shop search URLs or explicit FlixBus city UUIDs when you already know them.

Each output item represents one available trip quote for one route and departure date.

The actor is HTTP based and reads the same structured search data that powers the public FlixBus booking experience.

### Who is it for?

Travel aggregators use it to compare intercity bus options across routes and dates.

Fare-alert tools use it to detect price changes and notify travelers when a route becomes cheaper.

Route planners use it to collect departure windows, durations, and transfer types.

Market analysts use it to track availability and price levels on strategic corridors.

Tour operators use it to monitor travel costs for fixed city pairs.

Developers use it as a clean FlixBus data source for dashboards, alerts, and internal APIs.

### Why use this FlixBus scraper?

🚌 It returns fare data as rows you can export to JSON, CSV, Excel, or via API.

💶 It includes both base price and platform-fee-inclusive price when FlixBus exposes both values.

🕒 It captures departure and arrival timestamps plus duration in minutes.

📍 It includes city and station names when available in the FlixBus response.

🎯 It supports route pages, search URLs, and direct city UUID input.

### How much does it cost to scrape FlixBus trip prices?

The actor uses pay-per-event pricing.

You pay a small start fee per run and then a per-result fee for each trip price record saved.

Use `maxItems` to control cost during tests.

Start with one route and one date, confirm the output, then scale to more routes or date ranges.

Actual billing is shown by Apify before and after each run.

### Input options

`routes` is the main route configuration field.

Each route can contain a public FlixBus route page URL.

Each route can also contain a FlixBus shop search URL.

Advanced users can provide `fromCityId` and `toCityId` directly.

`startUrls` is supported for users who prefer the Apify request-list UI.

`departureDate` searches one day in `YYYY-MM-DD` format.

`dateRangeEnd` extends the search across multiple days.

`adults` controls the passenger count used in the fare quote.

`currency` requests prices in a FlixBus-supported currency such as `EUR`.

`locale` controls localized search behavior and booking URLs.

`maxItems` caps the number of saved trip records.

### Example input

```json
{
  "routes": [
    { "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon" }
  ],
  "departureDate": "2026-08-15",
  "adults": 1,
  "currency": "EUR",
  "locale": "en",
  "maxItems": 100
}
````

### Date range example

```json
{
  "routes": [
    {
      "fromCityId": "40de8964-8646-11e6-9066-549f350fcb0c",
      "toCityId": "40df89c1-8646-11e6-9066-549f350fcb0c"
    }
  ],
  "departureDate": "2026-08-15",
  "dateRangeEnd": "2026-08-21",
  "maxItems": 500
}
```

### Output data

The default dataset contains one item per FlixBus trip price result.

| Field | Description |
| --- | --- |
| `route` | Human-readable route label |
| `departureCity` | Departure city name |
| `arrivalCity` | Arrival city name |
| `departureStation` | Departure station name |
| `arrivalStation` | Arrival station name |
| `departureTime` | ISO departure timestamp |
| `arrivalTime` | ISO arrival timestamp |
| `travelDate` | Requested travel date |
| `durationMinutes` | Trip duration in minutes |
| `transferType` | Direct or transfer label |
| `provider` | Provider value returned by FlixBus |
| `price` | Base fare total |
| `priceWithPlatformFee` | Fare including platform fee when available |
| `currency` | Currency code |
| `availabilityStatus` | Availability status returned by FlixBus |
| `availableSeats` | Seats available when returned |
| `seatsLeftAtPrice` | Seats left at the current price level |
| `bikeSlots` | Bike slots when returned |
| `legsCount` | Number of legs in the itinerary |
| `rideIds` | FlixBus ride IDs for the legs |
| `bookingUrl` | URL users can open to continue booking |
| `scrapedAt` | Timestamp when the record was saved |

### Example output item

```json
{
  "route": "Paris → Lyon",
  "departureCity": "Paris",
  "arrivalCity": "Lyon",
  "departureStation": "Paris (Bercy Seine)",
  "arrivalStation": "Lyon (Gerland)",
  "departureTime": "2026-08-15T00:30:00+02:00",
  "arrivalTime": "2026-08-15T06:00:00+02:00",
  "durationMinutes": 330,
  "price": 62.99,
  "currency": "EUR",
  "availabilityStatus": "available"
}
```

### How to run

Open the actor on Apify.

Paste one or more FlixBus route URLs into `routes` or `startUrls`.

Choose a departure date.

Set `maxItems` to a low value for the first run.

Start the actor.

Download results from the dataset tab or consume them through the Apify API.

### Tips for best results

Use route pages from `global.flixbus.com` when possible.

Use future dates that FlixBus currently sells.

Keep date ranges small when monitoring many routes.

Use explicit city IDs for stable production workflows.

Use `maxItems` to limit spend while testing a new route set.

### Integrations

Connect the dataset to Google Sheets for daily fare-monitoring reports.

Use Apify webhooks to trigger price-alert workflows after each run.

Send output to a BI warehouse for route-market analysis.

Call the actor from a cron job to create a route fare history.

Combine it with notification tools to alert when `price` drops below a threshold.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/flixbus-trip-prices-scraper').call({
  routes: [{ url: 'https://global.flixbus.com/bus-routes/bus-paris-lyon' }],
  departureDate: '2026-08-15',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/flixbus-trip-prices-scraper').call(run_input={
    'routes': [{'url': 'https://global.flixbus.com/bus-routes/bus-paris-lyon'}],
    'departureDate': '2026-08-15',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~flixbus-trip-prices-scraper/runs?token=MY_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"routes":[{"url":"https://global.flixbus.com/bus-routes/bus-paris-lyon"}],"departureDate":"2026-08-15","maxItems":100}'
```

### MCP usage

You can use this actor through Apify MCP tools in Claude Code or Claude Desktop.

Use the actor-specific MCP URL:

`https://mcp.apify.com/?tools=automation-lab/flixbus-trip-prices-scraper`

Claude Code setup:

```bash
claude mcp add apify-flixbus-prices https://mcp.apify.com/?tools=automation-lab/flixbus-trip-prices-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-flixbus-prices": {
      "url": "https://mcp.apify.com/?tools=automation-lab/flixbus-trip-prices-scraper"
    }
  }
}
```

Example prompt:

"Run the FlixBus Trip Prices Scraper for Paris to Lyon next Friday and summarize the cheapest departures."

Another prompt:

"Monitor this FlixBus route URL for seven days and tell me which date has the lowest fare."

### Common workflows

Daily price monitoring for one city pair.

Weekly route-market snapshots across many city pairs.

Departure-time inventory checks for travel planning.

Price comparison between direct and connecting rides.

Availability tracking for routes with limited seats.

### Troubleshooting

If a route returns zero items, check that FlixBus sells tickets for the selected date.

If a route page cannot be resolved, try a shop search URL or explicit city IDs.

If you see fewer rows than expected, increase `maxItems`.

If prices differ from the website, confirm that currency, locale, passengers, and date match your browser search.

### Limitations

The actor only returns data exposed by public FlixBus search responses.

It does not complete bookings or collect passenger details.

It does not bypass account-only content.

FlixBus can change its public API or route availability at any time.

### Data freshness

Each record includes `scrapedAt`.

For price histories, schedule recurring runs and store datasets externally.

Do not assume prices are locked until a user completes checkout on FlixBus.

### Legality

This actor extracts publicly available fare-search data.

Use the data responsibly.

Respect FlixBus terms and applicable laws.

Do not use the output for spam, fraud, or abusive automation.

### Related scrapers

Other travel and mobility actors from automation-lab can complement this actor.

Ryanair flight price scraping can help compare bus and flight corridors.

Hotel or destination scrapers can enrich travel-planning dashboards.

Use only `https://apify.com/automation-lab/` actors when building internal workflows.

### FAQ

#### Can I search by city names?

The most reliable input is a FlixBus route URL or city UUID pair. Route URLs are easy to copy from the public FlixBus website.

#### Does it support multiple passengers?

Yes. Set `adults` to the number of adult passengers for the fare quote.

#### Can I monitor several routes?

Yes. Add multiple objects to `routes` and set a sensible `maxItems` limit.

#### Does it use a browser?

No. The actor is HTTP based for lower runtime cost and faster execution.

#### Can I book tickets with it?

No. It returns fare and availability data plus a booking URL. Booking happens on FlixBus.

# Actor input Schema

## `routes` (type: `array`):

FlixBus routes to search. Provide a route page/search URL or explicit FlixBus departure/arrival city UUIDs.

## `startUrls` (type: `array`):

Optional FlixBus route/search URLs. Useful when copying URLs directly from global.flixbus.com or shop.global.flixbus.com.

## `departureDate` (type: `string`):

Departure date to search in YYYY-MM-DD format.

## `dateRangeStart` (type: `string`):

Optional start date for a date range in YYYY-MM-DD format. Used when departureDate is not set.

## `dateRangeEnd` (type: `string`):

Optional end date for a date range in YYYY-MM-DD format. Limited to 31 days per run.

## `adults` (type: `integer`):

Number of adult passengers used in the fare quote.

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

Currency code requested from FlixBus, for example EUR or CHF.

## `locale` (type: `string`):

FlixBus locale code used for API responses and booking URLs.

## `includeAfterMidnightRides` (type: `boolean`):

Include late-night rides that cross midnight in the returned search results.

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

Maximum trip fare records to save across all routes and dates.

## Actor input object example

```json
{
  "routes": [
    {
      "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
    }
  ],
  "startUrls": [
    {
      "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
    }
  ],
  "departureDate": "2026-08-15",
  "adults": 1,
  "currency": "EUR",
  "locale": "en",
  "includeAfterMidnightRides": true,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "routes": [
        {
            "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
        }
    ],
    "startUrls": [
        {
            "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
        }
    ],
    "departureDate": "2026-08-15",
    "adults": 1,
    "currency": "EUR",
    "locale": "en",
    "includeAfterMidnightRides": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flixbus-trip-prices-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 = {
    "routes": [{ "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon" }],
    "startUrls": [{ "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon" }],
    "departureDate": "2026-08-15",
    "adults": 1,
    "currency": "EUR",
    "locale": "en",
    "includeAfterMidnightRides": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flixbus-trip-prices-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 '{
  "routes": [
    {
      "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
    }
  ],
  "startUrls": [
    {
      "url": "https://global.flixbus.com/bus-routes/bus-paris-lyon"
    }
  ],
  "departureDate": "2026-08-15",
  "adults": 1,
  "currency": "EUR",
  "locale": "en",
  "includeAfterMidnightRides": true,
  "maxItems": 20
}' |
apify call automation-lab/flixbus-trip-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FlixBus Trip Prices Scraper",
        "description": "Monitor FlixBus route fares, schedules, station names, durations, availability, and booking URLs for date-based bus price tracking.",
        "version": "0.1",
        "x-build-id": "moGn6LgbwYtZe4lbM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~flixbus-trip-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-flixbus-trip-prices-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/automation-lab~flixbus-trip-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-flixbus-trip-prices-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/automation-lab~flixbus-trip-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-flixbus-trip-prices-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": [
                    "departureDate"
                ],
                "properties": {
                    "routes": {
                        "title": "🚌 Routes to monitor",
                        "type": "array",
                        "description": "FlixBus routes to search. Provide a route page/search URL or explicit FlixBus departure/arrival city UUIDs."
                    },
                    "startUrls": {
                        "title": "Route URLs",
                        "type": "array",
                        "description": "Optional FlixBus route/search URLs. Useful when copying URLs directly from global.flixbus.com or shop.global.flixbus.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "departureDate": {
                        "title": "Departure date",
                        "type": "string",
                        "description": "Departure date to search in YYYY-MM-DD format."
                    },
                    "dateRangeStart": {
                        "title": "Date range start",
                        "type": "string",
                        "description": "Optional start date for a date range in YYYY-MM-DD format. Used when departureDate is not set."
                    },
                    "dateRangeEnd": {
                        "title": "Date range end",
                        "type": "string",
                        "description": "Optional end date for a date range in YYYY-MM-DD format. Limited to 31 days per run."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers used in the fare quote.",
                        "default": 1
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code requested from FlixBus, for example EUR or CHF.",
                        "default": "EUR"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "FlixBus locale code used for API responses and booking URLs.",
                        "default": "en"
                    },
                    "includeAfterMidnightRides": {
                        "title": "Include after-midnight rides",
                        "type": "boolean",
                        "description": "Include late-night rides that cross midnight in the returned search results.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum trips",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum trip fare records to save across all routes and dates.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
