# WorldFootball Scraper | Global Soccer Stats (`parseforge/worldfootball-net-scraper`) Actor

Pull soccer match results, league tables, player profiles, transfers, lineups, and historical records from WorldFootball.net across leagues worldwide. Perfect for football analytics, fantasy tools, betting models, sports journalism, and historical match research projects.

- **URL**: https://apify.com/parseforge/worldfootball-net-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚽ World Football Results Scraper

> 🚀 **Export historical football match results for 50+ competitions in seconds.** No login, no API key, just instant access to match data worldwide.

> 🕒 **Last updated:** 2026-05-22 · **📊 11 fields** per record · **380+ matches per season** · **Global coverage**

This actor scrapes historical football match results from [worldfootball.net](https://www.worldfootball.net) - one of the most comprehensive football statistics databases on the internet. Get structured match data including scores, dates, teams, and direct links to match reports for any major league or competition.

The data comes directly from worldfootball.net's public database, covering decades of football history across all major competitions.

### Coverage

- **8 major competitions** including Premier League, La Liga, Bundesliga, Serie A, Ligue 1, Champions League, Europa League, and FIFA World Cup
- **380+ matches** per top-flight league season
- **Full season history** - scrape any season by changing the season parameter
- **11 structured fields** per match record including scores, dates, team names, and match report URLs

### Target Audience / Use Cases

| Audience | Use Case |
|---|---|
| Sports analysts | Build performance databases and trend analysis |
| Betting researchers | Historical results for model training and verification |
| Journalists / bloggers | Quick access to verified historical match data |
| Data scientists | Football datasets for ML/AI research |
| Fantasy football managers | Historical team and match context |
| Developers | Populate apps with real football data |

### 📋 What the World Football Scraper does

- Fetches all match results for a selected competition and season in one run
- Extracts home team, away team, final score, and match date
- Provides direct links to full match report pages on worldfootball.net
- Supports 8 major competitions across Europe and the world
- Handles redirects and modern HTML structure automatically
- Respects free/paid user limits with clear messaging

> 💡 **Why it matters:** worldfootball.net is one of the few sites with consistent historical coverage across all major leagues. This actor makes that data available in clean, structured JSON, CSV, or Excel format in seconds.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `competition` | Select | Yes | The competition to scrape (see options below) |
| `season` | String | No | Season in YYYY-YYYY format, default: 2023-2024 |
| `maxItems` | Integer | No | Maximum number of matches to return |

**Competition options:**
- `eng-premier-league` - Premier League (England)
- `esp-primera-division` - La Liga (Spain)
- `bundesliga` - Bundesliga (Germany)
- `ita-serie-a` - Serie A (Italy)
- `fra-ligue-1` - Ligue 1 (France)
- `champions-league` - UEFA Champions League
- `europa-league` - UEFA Europa League
- `world-cup` - FIFA World Cup

**Example - Premier League 2023-24:**
```json
{
    "competition": "eng-premier-league",
    "season": "2023-2024",
    "maxItems": 100
}
````

**Example - Champions League 2022-23:**

```json
{
    "competition": "champions-league",
    "season": "2022-2023"
}
```

> ⚠️ **Good to Know:** Season format must match the worldfootball.net convention (e.g. `2023-2024` not `23/24`). Free users are limited to 10 results per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock full datasets.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📅 `date` | String | Match date in YYYY-MM-DD format |
| 🏠 `homeTeam` | String | Full name of the home team |
| ✈️ `awayTeam` | String | Full name of the away team |
| 🔢 `homeScore` | Integer | Goals scored by the home team (null if not played) |
| 🔢 `awayScore` | Integer | Goals scored by the away team (null if not played) |
| 📊 `result` | String | Final score in "H-A" format, e.g. "3-0" (null if not played) |
| 🏆 `competition` | String | Competition slug (e.g. eng-premier-league) |
| 📆 `season` | String | Season string (e.g. 2023-2024) |
| 🔗 `url` | String | Link to the full match report on worldfootball.net |
| 🕒 `scrapedAt` | String | ISO 8601 timestamp of when the record was collected |
| ❌ `error` | String | Error message if this record failed (always last) |

**Sample record:**

```json
{
    "date": "2023-08-11",
    "homeTeam": "Burnley FC",
    "awayTeam": "Manchester City",
    "homeScore": 0,
    "awayScore": 3,
    "result": "0-3",
    "competition": "eng-premier-league",
    "season": "2023-2024",
    "url": "https://www.worldfootball.net/match-report/co91/premier-league/ma9625838/burnley-fc_manchester-city/lineup/",
    "scrapedAt": "2026-05-22T10:00:00.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🌍 Multi-competition support | 8 major competitions including Champions League and World Cup |
| 📅 Full season history | Scrape any season, not just the current one |
| ⚡ Fast execution | Entire Premier League season (380 matches) in under 10 seconds |
| 🔗 Match report links | Direct URLs to full match reports for deeper research |
| 📦 Clean structured output | Ready for CSV, Excel, JSON, or direct API integration |
| 🆓 Free tier available | 10 matches free, no credit card required |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Football-data.org API |
|---|---|---|---|
| Setup time | Seconds | Hours | Minutes (needs API key) |
| Historical data | Yes | Depends | Limited in free tier |
| Competition variety | 8 major competitions | Any (manual) | Limited |
| Output format | JSON/CSV/Excel/XML | Raw HTML | JSON only |
| Cost | Free tier + PPE | Free | Subscription |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Go to the actor page and click **Try for free**
3. Select your competition (e.g. Premier League)
4. Enter the season (e.g. `2023-2024`)
5. Set `maxItems` if you want a partial dataset
6. Click **Start** and wait for results
7. Download as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Sports Analytics

Build historical databases to analyze team performance over seasons. Compare home vs away records, track goal-scoring trends, or identify patterns before upcoming fixtures.

#### Betting Research

Use historical match results as ground truth for building and validating predictive models. Cross-reference with odds data to find edges.

#### Media and Publishing

Journalists and bloggers can quickly pull verified historical results without manual research. Useful for "this day in football history" content or season reviews.

#### Application Development

Developers building football apps, dashboards, or fan tools can use this actor to seed databases with real historical match data across multiple competitions.

### 🔌 Automating World Football Scraper

Connect this actor to your favorite automation platform:

- **Make (Integromat)** - Schedule weekly runs to keep your football database current
- **Zapier** - Trigger downstream workflows when new results are collected
- **Slack** - Post match results summaries directly to your team channel
- **Google Sheets** - Auto-populate a spreadsheet with the latest results

### 🌟 Beyond business use cases

#### Research

Academic researchers studying sports economics, competitive balance, or home-field advantage can use this data as a clean baseline dataset across multiple leagues and seasons.

#### Personal Projects

Build your own football stats site, power a Discord bot with historical facts, or create visualizations of your favorite team's season trajectory.

#### Non-profit

Football coaching organizations can use historical data to prepare tactical analysis and scouting reports without manual data entry.

#### Experimentation

Data scientists can use multi-season, multi-league data to experiment with sports forecasting models, Elo rating systems, or machine learning classifiers.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant (ChatGPT, Claude, Gemini) questions like:

- "What does the worldfootball-net-scraper return?"
- "How do I get Bundesliga results for 2022-2023?"
- "What fields are available in the match output?"

### ❓ Frequently Asked Questions

**❓ Which competitions are supported?**
Premier League, La Liga, Bundesliga, Serie A, Ligue 1, UEFA Champions League, UEFA Europa League, and FIFA World Cup.

**❓ How many seasons can I scrape?**
Any season available on worldfootball.net. Simply change the `season` input parameter (e.g. `2020-2021`).

**❓ Does it include upcoming fixtures?**
Yes - matches not yet played will have `null` for scores and result.

**❓ How fast is it?**
A full Premier League season (380 matches) typically completes in under 15 seconds.

**❓ Is login required?**
No. This actor only accesses publicly available data.

**❓ Can I scrape multiple competitions at once?**
Run one actor instance per competition, or use Apify's scheduling to run them sequentially.

**❓ What format can I export the data in?**
JSON, CSV, Excel (XLSX), and XML are all available from the Apify dataset view.

**❓ How do I get World Cup data?**
Set `competition` to `world-cup`. For the 2022 World Cup use `season: 2022-2023`.

**❓ What if a competition isn't listed?**
The 8 listed competitions are the most popular. Additional competition support may be added in future versions.

**❓ Are historical seasons available?**
Yes. worldfootball.net has data going back many decades for most major competitions.

**❓ What does the `url` field link to?**
Each match URL links to the full match report on worldfootball.net, including lineups and match stats.

**❓ Is the data real-time?**
The data reflects what worldfootball.net has at the time of the run. For in-progress matches, scores may be incomplete.

### 🔌 Integrate with any app

Export your dataset and connect it to:

- Google Sheets via Apify's Google Sheets integration
- Airtable via CSV import
- PostgreSQL / MySQL via JSON import
- Power BI via JSON connector
- Tableau via CSV
- Custom REST APIs via Apify webhooks

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Transfermarkt Scraper](https://apify.com/parseforge) | Player valuations and transfer history |
| [Sofascore Scraper](https://apify.com/parseforge) | Live scores and statistics |
| [FlashScore Scraper](https://apify.com/parseforge) | Live match data and odds |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more sports and data scrapers built with the same quality standard.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This actor is an independent tool, not affiliated with, endorsed by, or sponsored by worldfootball.net. It accesses only publicly available data for informational and research purposes. Users are responsible for complying with worldfootball.net's terms of service and applicable laws.

# Actor input Schema

## `competition` (type: `string`):

Select the football competition to scrape results from.

## `season` (type: `string`):

The season to scrape (e.g. 2023-2024, 2022-2023). Use four-digit years separated by a hyphen.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "competition": "eng-premier-league",
  "season": "2023-2024",
  "maxItems": 10
}
```

# 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 = {
    "competition": "eng-premier-league",
    "season": "2023-2024",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/worldfootball-net-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 = {
    "competition": "eng-premier-league",
    "season": "2023-2024",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/worldfootball-net-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 '{
  "competition": "eng-premier-league",
  "season": "2023-2024",
  "maxItems": 10
}' |
apify call parseforge/worldfootball-net-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WorldFootball Scraper | Global Soccer Stats",
        "description": "Pull soccer match results, league tables, player profiles, transfers, lineups, and historical records from WorldFootball.net across leagues worldwide. Perfect for football analytics, fantasy tools, betting models, sports journalism, and historical match research projects.",
        "version": "0.1",
        "x-build-id": "UZGc8Rq7ddqqRAN2Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~worldfootball-net-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-worldfootball-net-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/parseforge~worldfootball-net-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-worldfootball-net-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/parseforge~worldfootball-net-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-worldfootball-net-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": [
                    "competition"
                ],
                "properties": {
                    "competition": {
                        "title": "Competition",
                        "enum": [
                            "eng-premier-league",
                            "esp-primera-division",
                            "bundesliga",
                            "ita-serie-a",
                            "fra-ligue-1",
                            "champions-league",
                            "europa-league",
                            "world-cup"
                        ],
                        "type": "string",
                        "description": "Select the football competition to scrape results from.",
                        "default": "eng-premier-league"
                    },
                    "season": {
                        "title": "Season",
                        "type": "string",
                        "description": "The season to scrape (e.g. 2023-2024, 2022-2023). Use four-digit years separated by a hyphen.",
                        "default": "2023-2024"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
