# World Rugby Rankings & Results Scraper (`crawlerbros/world-rugby-scraper`) Actor

Scrape official World Rugby data - men's and women's world rankings (current or historical by date), match results and fixtures across international and club rugby, and national team profiles. No login required.

- **URL**: https://apify.com/crawlerbros/world-rugby-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, 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

## World Rugby Rankings & Results Scraper

Scrape **World Rugby** (world.rugby) — the official global governing body's rankings and match data. Get current or historical men's and women's world rankings, match results and fixtures across international and club rugby, and national team profiles including Rugby World Cup history. HTTP-only via World Rugby's public data API. No auth, no proxy, no login.

### What this actor does

- **Three modes:** `rankings`, `matches`, `teamProfile`
- **World rankings:** men's and women's, current or any historical date
- **Match results & fixtures:** completed results and upcoming fixtures, XVs and Sevens, international and club rugby
- **Team profiles:** national team identity, Rugby World Cup finishes history, current ranking
- **Filters:** gender, date range, match status, team name, competition name
- **Empty fields are omitted** — every record only contains fields that were actually available for that team/match

### Output: rankings (mode = `rankings`)

- `teamId` — World Rugby numeric team ID
- `teamName`, `teamAbbreviation`, `countryCode`
- `gender` — `men` or `women`
- `rank`, `ratingPoints`
- `previousRank`, `previousRatingPoints` — from the prior ranking update
- `rankChange` — positive = moved up, negative = moved down
- `rankingDate` — the actual ranking-update date the snapshot reflects
- `sourceUrl`
- `recordType: "ranking"`, `scrapedAt`

### Output: matches (mode = `matches`)

- `matchId`, `competition`, `eventPhase` (e.g. `Final`, `Quarter-final`), `matchDescription` (e.g. `Match 48`)
- `gender`, `discipline` (`fifteens` or `sevens`)
- `matchDate`, `matchDateTimeUtc`
- `status` — `completed`, `upcoming`, `live` (match currently in progress), or `cancelled`
- `homeTeam`, `awayTeam`, `homeTeamId`, `awayTeamId`
- `homeScore`, `awayScore` — present once available
- `winner` — team name or `Draw` (completed matches only)
- `venueName`, `venueCity`, `venueCountry`
- `attendance` — reported crowd figure, when World Rugby publishes one (mostly major/marquee matches)
- `sourceUrl`
- `recordType: "match"`, `scrapedAt`

### Output: team profile (mode = `teamProfile`)

- `teamId`, `teamName`, `teamAbbreviation`
- `country`, `countryCode`, `teamType` (`Country` / `Club` / `Invitational`)
- `rwcBestFinish`, `rwcBestFinishYears`
- `rwcFinishHistory` — map of Rugby World Cup year → finish (e.g. `"2023": "winner"`)
- `currentRank`, `currentRatingPoints`, `gender` — when the team appears in the current world rankings
- `sourceUrl`
- `recordType: "team"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `rankings` | `rankings` / `matches` / `teamProfile` |
| `gender` | string | `men` | `men` / `women` / `both` (mode=rankings, mode=matches) |
| `rankingDate` | string | – | Historical snapshot date `YYYY-MM-DD` (mode=rankings) |
| `matchStatus` | string | `all` | `all` / `completed` / `upcoming` / `live` (mode=matches) |
| `includeSevens` | boolean | `false` | Also include Rugby Sevens matches (mode=matches) |
| `dateFrom` | string | 30 days ago | Match date range start `YYYY-MM-DD` (mode=matches) |
| `dateTo` | string | 30 days ahead | Match date range end `YYYY-MM-DD` (mode=matches) |
| `teamNameContains` | string | – | Filter matches to a team name substring (mode=matches) |
| `competitionContains` | string | – | Filter matches to a competition name substring (mode=matches) |
| `teamIds` | array | – | World Rugby numeric team IDs (mode=teamProfile) |
| `teamNames` | array | – | National team names, resolved via current rankings (mode=teamProfile); prefilled with `["New Zealand"]` for the platform's daily test run |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |

#### Example: current men's world rankings

```json
{
  "mode": "rankings",
  "gender": "men",
  "maxItems": 50
}
````

#### Example: historical women's rankings snapshot

```json
{
  "mode": "rankings",
  "gender": "women",
  "rankingDate": "2023-08-01",
  "maxItems": 50
}
```

#### Example: completed Six Nations results

```json
{
  "mode": "matches",
  "gender": "men",
  "matchStatus": "completed",
  "competitionContains": "Six Nations",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-04-01",
  "maxItems": 50
}
```

#### Example: national team profiles

```json
{
  "mode": "teamProfile",
  "teamNames": ["New Zealand", "South Africa", "Fiji"],
  "maxItems": 20
}
```

### Use cases

- **Sports media** — auto-publish weekly world ranking movements
- **Betting & fantasy sports** — feed live results and upcoming fixtures into models
- **Fan platforms & apps** — power a rugby results/rankings widget
- **Sports analytics** — build historical ranking-trend datasets by date
- **Research** — study national teams' World Cup performance history

### FAQ

**What is the data source?**
World Rugby's own public rankings and fixtures data (world.rugby), the sport's official global governing body.

**How far back does historical ranking data go?**
World Rugby's ranking system was introduced in 2003, but the public API backing this actor's historical snapshots has a different floor per gender: men's rankings only go back to around 2020-09, while women's rankings go back further, to around 2016-02. Requesting an earlier date than either floor returns the nearest (earliest) date that has data — confirmed live: requesting `rankingDate=2015-01-01` with `gender=men` returns the `2020-09-21` snapshot, while the same request with `gender=women` returns the `2016-02-08` snapshot instead. The actual date used is always returned in the `rankingDate` output field, so you can detect a clamp.

**Does `matches` mode cover club rugby too, not just internationals?**
Yes — `matches` returns any match on World Rugby's calendar in the date range, including major club competitions (e.g. Top 14, United Rugby Championship) alongside international Tests, since it draws on the same official results feed used across world.rugby.

**Why don't some matches have a score?**
Upcoming/fixture matches haven't been played yet, so `homeScore`/`awayScore`/`winner` are omitted until the match is completed.

**How do I find a team's `teamId` for `teamProfile` mode?**
Run `rankings` or `matches` mode first — every record includes `teamId` (and `homeTeamId`/`awayTeamId`). For national teams you can also just pass the team's name via `teamNames`.

**Is this affiliated with World Rugby?**
No — this is an independent, third-party actor built on World Rugby's publicly accessible data feed.

**What does `matchStatus: "live"` return?**
Matches currently being played — first half, half-time, or second half — with real-time scores. This is a small, transient set (usually 0-5 matches at any given moment, since most Test windows only have one or two matches kicking off at once); it will often be empty outside an active match window.

**Are there rate limits?**
The actor uses polite delays between requests. Very large `maxItems` values on `matches` mode may take longer since results are paginated 100 at a time.

# Actor input Schema

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

What to fetch.

## `gender` (type: `string`):

Which rankings/matches to fetch (mode=rankings, mode=matches). Also used to disambiguate `teamNames` when a country fields both a men's and a women's team of the same name (mode=teamProfile).

## `rankingDate` (type: `string`):

Historical ranking snapshot date, `YYYY-MM-DD`. Leave blank for the current rankings. World Rugby snaps to the nearest real ranking-update date to the one given (not always on/before it). The earliest available date depends on `gender`: men's data clamps at ~2020-09, women's data goes back further to ~2016-02. The actual date used is always returned in the `rankingDate` output field.

## `matchStatus` (type: `string`):

Filter matches by status. `live` returns matches currently in progress (first half, half-time, or second half).

## `includeSevens` (type: `boolean`):

Also include Rugby Sevens matches in addition to full XVs (15-a-side). Default only returns 15s.

## `dateFrom` (type: `string`):

Start of match date range, `YYYY-MM-DD`. Defaults to 30 days ago.

## `dateTo` (type: `string`):

End of match date range, `YYYY-MM-DD`. Defaults to 30 days ahead.

## `teamNameContains` (type: `string`):

Only keep matches where either team's name contains this text (case-insensitive), e.g. `Fiji`.

## `competitionContains` (type: `string`):

Only keep matches whose competition/tournament name contains this text (case-insensitive), e.g. `Six Nations`.

## `teamIds` (type: `array`):

World Rugby numeric team IDs (see `teamId` field in rankings/matches output), e.g. `39` for South Africa.

## `teamNames` (type: `array`):

National team names to resolve automatically against the current men's + women's rankings, e.g. `New Zealand`, `Fiji`. For club teams, use Team IDs instead.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "rankings",
  "gender": "men",
  "matchStatus": "all",
  "includeSevens": false,
  "teamIds": [],
  "teamNames": [
    "New Zealand"
  ],
  "maxItems": 50
}
```

# Actor output Schema

## `rugbyData` (type: `string`):

Dataset containing all scraped World Rugby rankings, matches, and team profiles.

# 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 = {
    "mode": "rankings",
    "gender": "men",
    "matchStatus": "all",
    "includeSevens": false,
    "teamIds": [],
    "teamNames": [
        "New Zealand"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/world-rugby-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 = {
    "mode": "rankings",
    "gender": "men",
    "matchStatus": "all",
    "includeSevens": False,
    "teamIds": [],
    "teamNames": ["New Zealand"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/world-rugby-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 '{
  "mode": "rankings",
  "gender": "men",
  "matchStatus": "all",
  "includeSevens": false,
  "teamIds": [],
  "teamNames": [
    "New Zealand"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/world-rugby-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "World Rugby Rankings & Results Scraper",
        "description": "Scrape official World Rugby data - men's and women's world rankings (current or historical by date), match results and fixtures across international and club rugby, and national team profiles. No login required.",
        "version": "1.0",
        "x-build-id": "dOsDv93hrcwPNzjjJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~world-rugby-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-world-rugby-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~world-rugby-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-world-rugby-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~world-rugby-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-world-rugby-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "rankings",
                            "matches",
                            "teamProfile"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "rankings"
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "men",
                            "women",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which rankings/matches to fetch (mode=rankings, mode=matches). Also used to disambiguate `teamNames` when a country fields both a men's and a women's team of the same name (mode=teamProfile).",
                        "default": "men"
                    },
                    "rankingDate": {
                        "title": "Ranking date (mode=rankings)",
                        "type": "string",
                        "description": "Historical ranking snapshot date, `YYYY-MM-DD`. Leave blank for the current rankings. World Rugby snaps to the nearest real ranking-update date to the one given (not always on/before it). The earliest available date depends on `gender`: men's data clamps at ~2020-09, women's data goes back further to ~2016-02. The actual date used is always returned in the `rankingDate` output field."
                    },
                    "matchStatus": {
                        "title": "Match status (mode=matches)",
                        "enum": [
                            "all",
                            "completed",
                            "upcoming",
                            "live"
                        ],
                        "type": "string",
                        "description": "Filter matches by status. `live` returns matches currently in progress (first half, half-time, or second half).",
                        "default": "all"
                    },
                    "includeSevens": {
                        "title": "Include Rugby Sevens (mode=matches)",
                        "type": "boolean",
                        "description": "Also include Rugby Sevens matches in addition to full XVs (15-a-side). Default only returns 15s.",
                        "default": false
                    },
                    "dateFrom": {
                        "title": "Date from (mode=matches)",
                        "type": "string",
                        "description": "Start of match date range, `YYYY-MM-DD`. Defaults to 30 days ago."
                    },
                    "dateTo": {
                        "title": "Date to (mode=matches)",
                        "type": "string",
                        "description": "End of match date range, `YYYY-MM-DD`. Defaults to 30 days ahead."
                    },
                    "teamNameContains": {
                        "title": "Team name contains (mode=matches)",
                        "type": "string",
                        "description": "Only keep matches where either team's name contains this text (case-insensitive), e.g. `Fiji`."
                    },
                    "competitionContains": {
                        "title": "Competition contains (mode=matches)",
                        "type": "string",
                        "description": "Only keep matches whose competition/tournament name contains this text (case-insensitive), e.g. `Six Nations`."
                    },
                    "teamIds": {
                        "title": "Team IDs (mode=teamProfile)",
                        "type": "array",
                        "description": "World Rugby numeric team IDs (see `teamId` field in rankings/matches output), e.g. `39` for South Africa.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "teamNames": {
                        "title": "National team names (mode=teamProfile)",
                        "type": "array",
                        "description": "National team names to resolve automatically against the current men's + women's rankings, e.g. `New Zealand`, `Fiji`. For club teams, use Team IDs instead.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```