# UK National Rail Scraper — Live Train Times, Boards & Delays (`jungle_synthesizer/national-rail-uk-timetable-scraper`) Actor

Scrape live UK rail data from National Rail: departure and arrival boards by station, real-time delays, cancellations, platforms, and operator info. Covers GWR, LNER, Avanti, Southern, Thameslink, ScotRail, TfW, Elizabeth line, CrossCountry, Northern, and more.

- **URL**: https://apify.com/jungle\_synthesizer/national-rail-uk-timetable-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

## National Rail UK Live Train Board Scraper

Scrape live departure and arrival boards from [nationalrail.co.uk](https://www.nationalrail.co.uk). Returns real-time service data — operator, scheduled and actual times, delays, platform assignments, cancellation reasons, and crowding levels — for any UK station by CRS code.

Every UK train operator is covered. GWR, LNER, Avanti West Coast, ScotRail, Southern, Thameslink, Transport for Wales, CrossCountry, Northern, the Elizabeth line — if it runs through a UK station, it appears here.

### National Rail UK Scraper Features

- **Extracts live departure and arrival boards** by station CRS code (3-letter identifier)
- **Returns real-time delay data** — scheduled vs. estimated vs. actual times, delay in minutes
- **Captures cancellation reasons** — not just the flag, but the text description when available
- **Covers all UK operators** — 20+ train operating companies in a single run
- **Includes platform assignments** when announced
- **Returns crowding level** per service (Unknown, Level1, Level2, Level3)
- **Supports multiple stations in one run** — pass a list of CRS codes, get boards for all of them
- **Pure HTML scraping** — no browser required, no JavaScript execution overhead

### What Can You Do With UK National Rail Data?

- **Travel app developers** — build live board displays, delay notifications, or journey planners on top of real-time NRE data
- **Data researchers** — track cancellation rates, delay patterns, and operator performance over time
- **MaaS platforms** — integrate UK rail data into multi-modal journey planning
- **Capacity planners** — monitor loading levels (crowding indicators) across routes
- **Journalists and analysts** — pull operator-level delay and cancellation data for reporting

### How It Works

1. **Configure your stations.** Provide one or more 3-letter CRS codes — the standard identifier for every UK rail station. King's Cross is KGX, Edinburgh Waverley is EDB, Manchester Piccadilly is MAN.
2. **Choose a board mode.** Departure board shows next trains leaving from each station. Arrival board shows incoming services.
3. **Run it.** The scraper fetches each station's live board from nationalrail.co.uk and parses the SSR-embedded service data. No waiting on JavaScript rendering.
4. **Get structured JSON.** Each service is a flat record with all timing fields, operator info, status, and platform — ready to pipe into a database, dashboard, or API.

### National Rail UK Scraper Input

```json
{
    "mode": "departure_board",
    "stations": ["KGX", "EDB", "MAN"],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "countryCode": "GB"
    }
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `departure_board` | `departure_board` or `arrival_board` |
| `stations` | array | `["KGX", "EDB"]` | List of 3-letter CRS station codes |
| `maxItems` | integer | `10` | Maximum total records to return across all stations |
| `proxyConfiguration` | object | UK Residential | Proxy settings — UK residential recommended |

**Finding CRS codes:** Every UK station has a 3-letter CRS code. National Rail publishes the full list at nationalrail.co.uk/stations. Common examples: LDN (London Victoria), EUS (London Euston), BHM (Birmingham New Street), GLC (Glasgow Central), LVP (Liverpool Lime Street).

### National Rail UK Scraper Output Fields

Each service record looks like this:

```json
{
    "station_name": "London Kings Cross",
    "station_crs": "KGX",
    "board_type": "departures",
    "rid": "202605116741058",
    "train_uid": "C41058",
    "operator": "London North Eastern Railway",
    "operator_code": "GR",
    "origin_station": "London Kings Cross",
    "origin_crs": "KGX",
    "destination_station": "Edinburgh",
    "destination_crs": "EDB",
    "scheduled_departure": "2026-05-11T09:30:00+01:00",
    "estimated_departure": null,
    "actual_departure": "2026-05-11T09:29:46+01:00",
    "scheduled_arrival": "2026-05-11T13:38:00+01:00",
    "estimated_arrival": "2026-05-11T13:38:00+01:00",
    "actual_arrival": null,
    "delay_minutes": 0,
    "platform": "8",
    "status": "OnTime",
    "cancelled": false,
    "cancellation_reason": null,
    "stops_count": 3,
    "service_category": "ExpressPassengerTrain",
    "loading_level": "Unknown",
    "scraped_at": "2026-05-11T08:31:00.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `station_name` | string | Name of the queried station |
| `station_crs` | string | 3-letter CRS code of the queried station |
| `board_type` | string | `departures` or `arrivals` |
| `rid` | string | Run ID — unique service identifier for this running |
| `train_uid` | string | Train UID (timetable identifier) |
| `operator` | string | Train operating company name |
| `operator_code` | string | 2-letter TOC code (GR, GW, SR, etc.) |
| `origin_station` | string | Origin station name |
| `origin_crs` | string | Origin station CRS code |
| `destination_station` | string | Destination station name |
| `destination_crs` | string | Destination station CRS code |
| `scheduled_departure` | string | Scheduled departure (ISO 8601) |
| `estimated_departure` | string | Real-time estimated departure, null if unavailable |
| `actual_departure` | string | Actual departure time, null if not yet departed |
| `scheduled_arrival` | string | Scheduled arrival at destination (ISO 8601) |
| `estimated_arrival` | string | Real-time estimated arrival, null if unavailable |
| `actual_arrival` | string | Actual arrival time, null if not yet arrived |
| `delay_minutes` | number | Delay in minutes (positive = late), null if no real-time data |
| `platform` | string | Platform number or letter, null if not yet announced |
| `status` | string | OnTime, Late, Cancelled, Arrived, or Departed |
| `cancelled` | boolean | True if the service is cancelled |
| `cancellation_reason` | string | Reason text when cancelled, null otherwise |
| `stops_count` | number | Number of intermediate stops |
| `service_category` | string | ExpressPassengerTrain or PassengerTrain |
| `loading_level` | string | Crowding: Unknown, Level1 (quiet), Level2 (busy), Level3 (very busy) |
| `scraped_at` | string | ISO 8601 timestamp when this record was collected |

### 🔍 FAQ

#### How do I scrape UK train departure boards?

National Rail UK Scraper takes a list of CRS station codes and fetches the live departure or arrival board for each one. Pass `stations: ["KGX"]` and `mode: "departure_board"` to get the next departures from London King's Cross. The result is structured JSON — no screen-scraping glue required.

#### How much does National Rail UK Scraper cost?

The actor charges $0.10 per run start plus $0.0015 per service record returned. A run fetching 20 records from two stations costs roughly $0.13.

#### Does National Rail UK Scraper need proxies?

Yes. UK residential proxy is required for reliable results from nationalrail.co.uk. The default proxy configuration (`RESIDENTIAL`, country `GB`) is pre-filled — leave it as-is unless you're testing at low volume.

#### What is a CRS code?

CRS stands for Computer Reservation System — it's the 3-letter station identifier used across UK rail. Every station in the National Rail network has one. King's Cross is KGX, Edinburgh Waverley is EDB, Manchester Piccadilly is MAN, Birmingham New Street is BHM. National Rail publishes the full list on their website.

#### Can I get historical timetable data?

National Rail UK Scraper returns live board data — the next ~10 services from each station at the time of the run. It doesn't cover historical schedules or full 24-hour timetables. For historical data, the OpenTrainTimes API or the Darwin/LDBWS feeds (commercial licensing required) are the appropriate sources.

***

### Need More Features?

Need custom filters, additional stations, or a different data source? [File an issue](https://console.apify.com/actors/zVhikjDvt8KNdD3Rh/issues) or get in touch.

### Why Use National Rail UK Scraper?

- **Zero competition** — first UK rail live board scraper on Apify, which covers the entire national network through a single source
- **Clean output** — flat JSON records with consistent field names, ISO 8601 timestamps, and explicit null fields so your pipeline doesn't guess
- **All operators** — every UK TOC in one place: LNER, GWR, Avanti, ScotRail, TfW, CrossCountry, Northern, Southern, Southeastern, and more

# 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.

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

No description

## `stations` (type: `array`):

List of 3-letter CRS station codes to query (e.g. \['KGX', 'EDB', 'MAN']). At least one required.

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

Maximum total service records to return across all queried stations.

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

UK residential proxy required for reliable results.

## 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...",
  "mode": "departure_board",
  "stations": [
    "KGX",
    "EDB"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "GB"
  }
}
```

# 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...",
    "mode": "departure_board",
    "stations": [
        "KGX",
        "EDB"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "countryCode": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/national-rail-uk-timetable-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...",
    "mode": "departure_board",
    "stations": [
        "KGX",
        "EDB",
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "countryCode": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/national-rail-uk-timetable-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...",
  "mode": "departure_board",
  "stations": [
    "KGX",
    "EDB"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "GB"
  }
}' |
apify call jungle_synthesizer/national-rail-uk-timetable-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK National Rail Scraper — Live Train Times, Boards & Delays",
        "description": "Scrape live UK rail data from National Rail: departure and arrival boards by station, real-time delays, cancellations, platforms, and operator info. Covers GWR, LNER, Avanti, Southern, Thameslink, ScotRail, TfW, Elizabeth line, CrossCountry, Northern, and more.",
        "version": "1.0",
        "x-build-id": "GvBhd2pc0umZtV1CM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~national-rail-uk-timetable-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-national-rail-uk-timetable-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~national-rail-uk-timetable-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-national-rail-uk-timetable-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~national-rail-uk-timetable-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-national-rail-uk-timetable-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": [
                    "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."
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "departure_board",
                            "arrival_board"
                        ],
                        "type": "string",
                        "description": ""
                    },
                    "stations": {
                        "title": "Station CRS Codes",
                        "type": "array",
                        "description": "List of 3-letter CRS station codes to query (e.g. ['KGX', 'EDB', 'MAN']). At least one required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "Maximum total service records to return across all queried stations.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "UK residential proxy required for reliable results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
