# Squiggle AFL Games Scraper (`parseforge/squiggle-afl-scraper`) Actor

Pull AFL games and results from the Squiggle API by season and round. Each match returns home and away clubs, exact scores, goals, behinds, the winner, the margin, the venue, and kick off time. Also grabs teams, the ladder, and model tips. Great for sports analytics and tipping.

- **URL**: https://apify.com/parseforge/squiggle-afl-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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)

## 🏉 Squiggle AFL Scraper

> 🚀 **Export a full round of AFL results in seconds.** Pull every game, score, venue, winner and margin from the Squiggle API, plus teams, the ladder, and model tips.

> 🕒 **Last updated:** 2026-06-05 · **📊 27 fields** per game record · 18 AFL clubs · seasons back to 1897

The Squiggle AFL Scraper turns the public Squiggle API into clean, structured datasets covering the Australian Football League. Point it at a season and round and get back home and away teams, exact scores broken down into goals and behinds, the winner, the margin, the venue, kick-off times in local and UTC, and completion status for every match.

Beyond match results, the same Actor pulls the full club directory, the ladder/standings (wins, losses, points, percentage, points for and against), and the crowd of tipping models that Squiggle aggregates (each model's predicted winner, confidence, predicted margin, and whether the tip was correct). Coverage spans the modern AFL era, with games data reaching back to the league's earliest seasons.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sports analysts and data scientists | Building AFL results and ladder datasets |
| Fantasy and tipping competition players | Comparing model tips and confidence |
| Journalists and bloggers | Pulling fixtures, scores, and margins |
| App and dashboard developers | Powering AFL stats widgets |

### 📋 What the Squiggle AFL Scraper does

- Pulls AFL **games / results** for any season and round: teams, scores, goals, behinds, winner, margin, venue, dates, and completion status.
- Returns the full **teams** directory with abbreviations, debut years, and logos.
- Pulls the **standings / ladder** with wins, losses, draws, points, percentage, and points for and against.
- Pulls **tips / predictions** from the models Squiggle aggregates, including confidence and predicted margin.
- Lets you filter by **data type**, **season year**, and **round**.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `query` | select | Data type to pull: `games`, `teams`, `standings`, or `tips`. Default `games`. |
| `year` | integer | Season year, e.g. `2024`. Applies to games, standings, and tips. |
| `round` | integer | Round number within the season, e.g. `1`. Applies to games, standings, and tips. |
| `maxItems` | integer | Free users limited to 10 items. Paid users up to 1,000,000. |

Example 1 — Round 1 results for the 2024 season:

```json
{
  "query": "games",
  "year": 2024,
  "round": 1,
  "maxItems": 10
}
````

Example 2 — The 2024 ladder after round 1:

```json
{
  "query": "standings",
  "year": 2024,
  "round": 1,
  "maxItems": 18
}
```

> ⚠️ **Good to Know:** The `teams` data type ignores `year` and `round` and always returns the current club list. For `games`, `standings`, and `tips`, leaving `round` empty pulls the whole season at once.

### 📊 Output

| Field | Description |
|---|---|
| 🆔 `gameId` | Unique Squiggle match identifier |
| 🏉 `roundName` | Human round label, e.g. Round 1 |
| 🏠 `homeTeam` | Home club name |
| 🔢 `homeScore` | Home total points |
| ✈ `awayTeam` | Away club name |
| 🔢 `awayScore` | Away total points |
| 🏆 `winner` | Winning club name |
| 📏 `margin` | Winning margin in points |
| 📍 `venue` | Match venue |
| 📅 `date` | Scheduled date and time |
| ✅ `complete` | Completion percentage of the match |
| 🕒 `scrapedAt` | Timestamp the record was collected |
| ❌ `error` | Null on success, message on failure |

Games records also include `year`, `round`, `homeTeamId`, `homeGoals`, `homeBehinds`, `awayTeamId`, `awayGoals`, `awayBehinds`, `winnerTeamId`, `localtime`, `timezone`, `unixtime`, `timeStatus`, `isFinal`, `isGrandFinal`, and `updated`.

Sample records (real output):

```json
[
  {
    "gameId": 35704,
    "roundName": "Round 1",
    "homeTeam": "Carlton",
    "homeScore": 86,
    "awayTeam": "Richmond",
    "awayScore": 81,
    "winner": "Carlton",
    "margin": 5,
    "venue": "M.C.G.",
    "date": "2024-03-14 19:30:00",
    "complete": 100,
    "scrapedAt": "2026-06-05T17:03:24.339Z",
    "error": null
  },
  {
    "gameId": 35705,
    "roundName": "Round 1",
    "homeTeam": "Collingwood",
    "homeScore": 69,
    "awayTeam": "Sydney",
    "awayScore": 102,
    "winner": "Sydney",
    "margin": 33,
    "venue": "M.C.G.",
    "date": "2024-03-15 19:40:00",
    "complete": 100,
    "scrapedAt": "2026-06-05T17:03:24.464Z",
    "error": null
  },
  {
    "gameId": 35706,
    "roundName": "Round 1",
    "homeTeam": "Essendon",
    "homeScore": 107,
    "awayTeam": "Hawthorn",
    "awayScore": 83,
    "winner": "Essendon",
    "margin": 24,
    "venue": "M.C.G.",
    "date": "2024-03-16 13:45:00",
    "complete": 100,
    "scrapedAt": "2026-06-05T17:03:24.489Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- **Four data types in one Actor.** Games, teams, ladder, and tips share one simple input.
- **Clean, typed fields.** Scores, goals, behinds, and margins arrive as numbers, dates as readable strings, with computed winning margins on every game.
- **Deep history.** Games data reaches back to the earliest AFL/VFL seasons.
- **Predictable shape.** Every record ends with `scrapedAt` and `error`, so failures never break your pipeline.

### 📈 How it compares to alternatives

| Approach | Setup | Structured output | Maintenance |
|---|---|---|---|
| This Actor | Pick a season and round | Yes, ready to use | None on your side |
| Manual API calls | Read API docs, write code | You build the parser | You own it |
| Copy from a results page | Slow, error prone | No | High |

### 🚀 How to use

1. [Sign up for a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Squiggle AFL Scraper.
3. Choose a data type (`games`, `teams`, `standings`, or `tips`) and set the season and round.
4. Click **Start** and watch records stream into your dataset.
5. View the results in the dataset table or pull them through the Apify API.

### 💼 Business use cases

**Media and publishing**

| Need | How this helps |
|---|---|
| Fixture and results widgets | Pull scores, venues, and margins per round |
| Match recaps | Get winner, margin, and goal/behind breakdowns |

**Analytics and modelling**

| Need | How this helps |
|---|---|
| Build a results dataset | Collect every game across seasons |
| Backtest tip models | Compare predicted margins to outcomes |

**Tipping and fantasy products**

| Need | How this helps |
|---|---|
| Aggregate model tips | Pull confidence and predicted winners |
| Ladder context | Read wins, losses, points, and percentage |

**App development**

| Need | How this helps |
|---|---|
| Power a stats app | Feed structured AFL data into your backend |
| Keep clubs in sync | Pull the team directory with abbreviations |

### 🔌 Automating Squiggle AFL Scraper

Connect the Actor to the tools you already use:

- **Make** and **Zapier** for no-code workflows.
- **Slack** to post round results to a channel.
- **Airbyte** to load data into a warehouse.
- **GitHub Actions** to schedule pulls.
- **Google Drive** to archive each round's dataset.

### 🌟 Beyond business use cases

- **Research:** study scoring trends, home advantage, and venue effects across seasons.
- **Personal:** track your club's results and ladder position.
- **Non-profit:** power community sports newsletters and round-ups.
- **Experimentation:** train and test your own AFL prediction models.

### 🤖 Ask an AI assistant

Drop the dataset into your favourite assistant and ask it to summarise a round or find upsets:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**What data does this Actor return?**
AFL games and results, the team directory, the ladder/standings, and aggregated model tips.

**Where does the data come from?**
The public Squiggle API for Australian Football League data.

**How far back does games data go?**
Games coverage reaches back to the earliest AFL/VFL seasons. Use the `year` filter to choose one.

**Can I pull a whole season at once?**
Yes. Leave the `round` field empty to pull every round for the chosen season.

**Does the teams query use year and round?**
No. The `teams` query always returns the current club list and ignores those filters.

**What is the margin field?**
The absolute difference between home and away scores, computed for every game.

**What is in the tips data?**
Each tipping model's predicted winner, confidence, predicted margin, and whether the tip was correct.

**Why are some game scores zero or incomplete?**
Matches that have not finished show a lower `complete` percentage and may have partial scores.

**How many items can I get?**
Free accounts get up to 10 items per run. Paid accounts can pull up to 1,000,000.

**Is there a rate limit?**
The Actor sends a descriptive User-Agent and retries gracefully on transient errors.

### 🔌 Integrate with any app

Every run writes to an Apify dataset you can read through the Apify API or connect to Make, Zapier, Airbyte, and more. Build dashboards, alerts, or scheduled archives with no extra glue code.

### 🔗 Recommended Actors

- **Understat xG Player Stats Scraper** for football expected goals data.
- **FPL Premier League Scraper** for Fantasy Premier League stats.
- **Steam Store Scraper** for game catalog data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

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

> **⚠️ Disclaimer:** independent tool, not affiliated with Squiggle or the AFL. Only publicly available data is collected.

# Actor input Schema

## `query` (type: `string`):

Which AFL data to pull from Squiggle. Games returns match results, teams returns the club list, standings returns the ladder, tips returns model predictions.

## `year` (type: `integer`):

AFL season year, e.g. 2024. Applies to games, standings and tips. Leave default for the most recent complete season.

## `round` (type: `integer`):

Round number within the season, e.g. 1. Applies to games, standings and tips. Leave empty to pull the whole season.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## Actor input object example

```json
{
  "query": "games",
  "year": 2024,
  "round": 1,
  "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 = {
    "year": 2024,
    "round": 1,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/squiggle-afl-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 = {
    "year": 2024,
    "round": 1,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/squiggle-afl-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 '{
  "year": 2024,
  "round": 1,
  "maxItems": 10
}' |
apify call parseforge/squiggle-afl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Squiggle AFL Games Scraper",
        "description": "Pull AFL games and results from the Squiggle API by season and round. Each match returns home and away clubs, exact scores, goals, behinds, the winner, the margin, the venue, and kick off time. Also grabs teams, the ladder, and model tips. Great for sports analytics and tipping.",
        "version": "0.1",
        "x-build-id": "YE9wHPpLFjCSunHaM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~squiggle-afl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-squiggle-afl-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~squiggle-afl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-squiggle-afl-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~squiggle-afl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-squiggle-afl-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Data Type",
                        "enum": [
                            "games",
                            "teams",
                            "standings",
                            "tips"
                        ],
                        "type": "string",
                        "description": "Which AFL data to pull from Squiggle. Games returns match results, teams returns the club list, standings returns the ladder, tips returns model predictions.",
                        "default": "games"
                    },
                    "year": {
                        "title": "Season (year)",
                        "minimum": 1897,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "AFL season year, e.g. 2024. Applies to games, standings and tips. Leave default for the most recent complete season."
                    },
                    "round": {
                        "title": "Round",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Round number within the season, e.g. 1. Applies to games, standings and tips. Leave empty to pull the whole season."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```