# College Football Roster Scraper (`ericfox/college-football-roster-scraper-apify`) Actor

Scrape college football roster pages into clean player datasets. Extract names, jersey numbers, positions, class year, height, weight, hometown, profile URLs, and headshots from FCS/default URLs or custom roster links. Includes adapters for multiple athletics site formats.

- **URL**: https://apify.com/ericfox/college-football-roster-scraper-apify.md
- **Developed by:** [Eric F](https://apify.com/ericfox) (community)
- **Categories:** Other, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## College Football Roster Scraper for Apify

A production-oriented Apify Actor that scrapes public college football roster pages into normalized, player-only rows.

This upgraded version uses adapter-based extraction instead of a single generic selector pass. It is designed for the exact roster issues that came up during the FCS roster build: Sidearm card pages, Presto-style pages, header-table pages, outlier card layouts, duplicate mobile/desktop player cards, `View Bio` name noise, player names recoverable only from `/roster/name/id` URLs, and pages that should report diagnostics instead of silently returning zero rows.

### What it extracts

Each player row is pushed to the default Apify dataset with fields like:

```json
{
  "scraped_at": "2026-06-22T00:00:00.000Z",
  "sport": "football",
  "season": "2025",
  "team_name": "North Dakota State",
  "roster_url": "https://gobison.com/sports/football/roster/2025",
  "source_url": "https://gobison.com/sports/football/roster/2025",
  "source_platform": "sidearm+table+generic-card",
  "player_profile_url": "https://gobison.com/sports/football/roster/example-player/12345",
  "headshot_url": "https://...jpg",
  "headshot_confidence": "high",
  "first_name": "Example",
  "last_name": "Player",
  "full_name": "Example Player",
  "jersey_number": "12",
  "position": "QB",
  "height": "6'2",
  "height_inches": 74,
  "weight": "205",
  "class_year": "JR",
  "hometown": "Lewes, Del.",
  "high_school": "Cape Henlopen",
  "previous_school": "",
  "extraction_method": "sidearm_card"
}
````

### Included adapters

The Actor runs these adapters in `auto` mode:

1. **Sidearm adapter**
   - Targets `.sidearm-roster-player` and related roster-card classes.
   - Handles duplicate card layouts and `View Bio`/`Full Bio` noise.
   - Recovers names from profile URL slugs when the visible link text is useless.

2. **Presto-style adapter**
   - Targets common Presto roster/card wrappers and falls back to the table parser.
   - Useful for smaller-school athletics sites with less consistent markup.

3. **JSON-state adapter**
   - Scans valid JSON data in `application/ld+json`, `__NEXT_DATA__`, and state-like script blobs.
   - Extracts player records only when the object has roster-like evidence such as position, jersey, class, height, or weight.

4. **Header table adapter**
   - Uses header names rather than fixed cell indexes.
   - This avoids the earlier failure mode where `cells[0]`, `cells[1]`, etc. misassigned jersey, height, class, and weight on outlier tables.

5. **Heuristic table/card fallback**
   - Attempts a final extraction pass for pages with no obvious platform markers.
   - Uses profile links, position/height/weight/class patterns, and player-only filtering.

### Player-only behavior

The extractor attempts to avoid coaches/staff by:

- preferring `/sports/football/roster/` or `/roster/` profile links
- excluding `/coach/` and `/coaches/` links
- excluding cards/rows with staff terms such as coach, coordinator, assistant, trainer, operations, analyst, recruiting, staff, etc.
- requiring roster-like evidence such as position, height, weight, class year, jersey number, or a roster profile URL

This is a data-cleaning filter, not a legal/compliance filter.

### Included default/demo dataset

The bundled default list lives here:

```text
src/default-fcs-roster-urls.js
```

The input option `useDefaultFcsUrls` is `true` by default. To avoid accidentally crawling the full list during testing, `maxRosterUrls` defaults to `10`. Set `maxRosterUrls` to `0` to crawl every bundled URL.

### Run locally

Install Apify CLI first if you have not already:

```bash
npm install -g apify-cli
apify login
```

Then run:

```bash
npm install
npm run check
npm run test:fixtures
apify run -p sample-input.json
```

Local dataset output will appear under:

```text
storage/datasets/default/
```

Run summaries are saved to the default key-value store:

```text
RUN_SUMMARY
ZERO_PLAYER_PAGES
```

### Deploy to Apify

From the project folder:

```bash
apify push
```

Then open the Actor in Apify Console and run it with the default input.

### Suggested first tests

Start with 3 to 5 pages:

```json
{
  "useDefaultFcsUrls": true,
  "season": "2025",
  "maxRosterUrls": 5,
  "maxConcurrency": 3,
  "startUrls": []
}
```

Then test one custom roster URL:

```json
{
  "useDefaultFcsUrls": false,
  "season": "2025",
  "maxRosterUrls": 0,
  "startUrls": [
    {
      "url": "https://gobison.com/sports/football/roster/2025",
      "userData": {
        "team_name": "North Dakota State"
      }
    }
  ]
}
```

### Debugging outlier pages

If a roster URL returns no players, check the key-value store record:

```text
ZERO_PLAYER_PAGES
```

It includes:

- page URL
- team name
- detected source platform
- page title and `h1`
- table count
- image count
- roster link count
- Sidearm card count
- per-adapter row counts/errors
- a short body-text sample

You can also enable `emitDiagnosticRows` in input to push a visible diagnostic row into the dataset, but keep it disabled for clean production exports.

### Commercial / Apify Store notes

For a public Apify Store listing, position it as a normalized public roster data extractor, not as a copyrighted media downloader. The Actor returns image URLs only; it does not download or rehost headshot images.

Recommended store copy:

> Scrape public college football roster pages into clean CSV/JSON player rows, including names, jersey numbers, positions, height, weight, class year, hometown, profile URLs, and headshot URLs. Built for FCS and college athletics roster workflows.

### Practical limits

College athletics sites are not perfectly standardized. This Actor now has a real adapter layer, but a handful of domains may still need school/domain-specific micro-adapters after you see live failure diagnostics. The intended workflow is:

1. Run a small sample.
2. Inspect `ZERO_PLAYER_PAGES`.
3. Add a domain adapter only for the pages that still fail.
4. Re-run the full default FCS list.

# Actor input Schema

## `useDefaultFcsUrls` (type: `boolean`):

When enabled, the Actor uses the bundled 2025 FCS roster URL list as the demo/default source set. Add startUrls below to merge custom URLs into the run.

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

Optional additional college football roster page URLs. Each item can include userData.team\_name.

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

Optional season value to place on each result. If blank, the Actor tries to infer it from /roster/2025-style URLs.

## `sport` (type: `string`):

Output label. Keep as football for this Actor unless adapting the selectors for another sport.

## `maxRosterUrls` (type: `integer`):

Safety cap for the number of roster pages to crawl. Set to 0 to run the full bundled/default list.

## `maxPlayersPerTeam` (type: `integer`):

Optional cap per roster page. Set to 0 for no cap.

## `adapterMode` (type: `string`):

Auto runs the platform/domain adapters plus safe fallbacks. Use a specific adapter only for debugging a problem domain.

## `emitDiagnosticRows` (type: `boolean`):

When enabled, pages with no extracted players add a visible diagnostic row to the dataset. Detailed diagnostics are always saved in ZERO\_PLAYER\_PAGES and RUN\_SUMMARY key-value records.

## `maxConcurrency` (type: `integer`):

How many roster pages to fetch in parallel. Keep moderate for school athletics sites.

## `maxRequestRetries` (type: `integer`):

Number of retries for failed roster page requests.

## `requestHandlerTimeoutSecs` (type: `integer`):

How long to allow extraction from each roster page before timing out.

## `navigationTimeoutSecs` (type: `integer`):

How long to wait for each page HTTP response.

## `useSessionPool` (type: `boolean`):

Keep enabled for more stable crawling across many athletics domains.

## `respectRobotsTxtFile` (type: `boolean`):

Enable this if you want the crawler to obey robots.txt for each domain. You should still review source-site terms before commercial reuse.

## Actor input object example

```json
{
  "useDefaultFcsUrls": true,
  "startUrls": [],
  "season": "2025",
  "sport": "football",
  "maxRosterUrls": 10,
  "maxPlayersPerTeam": 0,
  "adapterMode": "auto",
  "emitDiagnosticRows": false,
  "maxConcurrency": 10,
  "maxRequestRetries": 2,
  "requestHandlerTimeoutSecs": 45,
  "navigationTimeoutSecs": 30,
  "useSessionPool": true,
  "respectRobotsTxtFile": false
}
```

# Actor output Schema

## `players` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `zeroPlayerPages` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ericfox/college-football-roster-scraper-apify").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("ericfox/college-football-roster-scraper-apify").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 '{}' |
apify call ericfox/college-football-roster-scraper-apify --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "College Football Roster Scraper",
        "description": "Scrape college football roster pages into clean player datasets. Extract names, jersey numbers, positions, class year, height, weight, hometown, profile URLs, and headshots from FCS/default URLs or custom roster links. Includes adapters for multiple athletics site formats.",
        "version": "0.0",
        "x-build-id": "VhVMOtNzzpwT5K8A7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ericfox~college-football-roster-scraper-apify/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ericfox-college-football-roster-scraper-apify",
                "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/ericfox~college-football-roster-scraper-apify/runs": {
            "post": {
                "operationId": "runs-sync-ericfox-college-football-roster-scraper-apify",
                "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/ericfox~college-football-roster-scraper-apify/run-sync": {
            "post": {
                "operationId": "run-sync-ericfox-college-football-roster-scraper-apify",
                "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",
                "properties": {
                    "useDefaultFcsUrls": {
                        "title": "Use bundled FCS roster URL dataset",
                        "type": "boolean",
                        "description": "When enabled, the Actor uses the bundled 2025 FCS roster URL list as the demo/default source set. Add startUrls below to merge custom URLs into the run.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "Additional roster URLs",
                        "type": "array",
                        "description": "Optional additional college football roster page URLs. Each item can include userData.team_name.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "season": {
                        "title": "Season label",
                        "type": "string",
                        "description": "Optional season value to place on each result. If blank, the Actor tries to infer it from /roster/2025-style URLs.",
                        "default": "2025"
                    },
                    "sport": {
                        "title": "Sport label",
                        "type": "string",
                        "description": "Output label. Keep as football for this Actor unless adapting the selectors for another sport.",
                        "default": "football"
                    },
                    "maxRosterUrls": {
                        "title": "Max roster URLs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap for the number of roster pages to crawl. Set to 0 to run the full bundled/default list.",
                        "default": 10
                    },
                    "maxPlayersPerTeam": {
                        "title": "Max players per team",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap per roster page. Set to 0 for no cap.",
                        "default": 0
                    },
                    "adapterMode": {
                        "title": "Adapter mode",
                        "enum": [
                            "auto",
                            "sidearm",
                            "presto",
                            "json-state",
                            "table",
                            "generic-card"
                        ],
                        "type": "string",
                        "description": "Auto runs the platform/domain adapters plus safe fallbacks. Use a specific adapter only for debugging a problem domain.",
                        "default": "auto"
                    },
                    "emitDiagnosticRows": {
                        "title": "Emit diagnostic rows for zero-player pages",
                        "type": "boolean",
                        "description": "When enabled, pages with no extracted players add a visible diagnostic row to the dataset. Detailed diagnostics are always saved in ZERO_PLAYER_PAGES and RUN_SUMMARY key-value records.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many roster pages to fetch in parallel. Keep moderate for school athletics sites.",
                        "default": 10
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of retries for failed roster page requests.",
                        "default": 2
                    },
                    "requestHandlerTimeoutSecs": {
                        "title": "Request handler timeout seconds",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "How long to allow extraction from each roster page before timing out.",
                        "default": 45
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation timeout seconds",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait for each page HTTP response.",
                        "default": 30
                    },
                    "useSessionPool": {
                        "title": "Use session pool",
                        "type": "boolean",
                        "description": "Keep enabled for more stable crawling across many athletics domains.",
                        "default": true
                    },
                    "respectRobotsTxtFile": {
                        "title": "Respect robots.txt",
                        "type": "boolean",
                        "description": "Enable this if you want the crawler to obey robots.txt for each domain. You should still review source-site terms before commercial reuse.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```