# StubHub Ticket Resale Scraper (`jungle_synthesizer/stubhub-ticket-resale-scraper`) Actor

Scrape seller-level ticket resale listings from StubHub — concerts, sports and theater. Returns section, row, seat range, quantity, price, fees, face value and ticket class per listing, plus an event record with venue, date and lowest price.

- **URL**: https://apify.com/jungle\_synthesizer/stubhub-ticket-resale-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** E-commerce, Sports
- **Stats:** 5 total users, 3 monthly users, 92.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## StubHub Ticket Resale Scraper

Scrapes seller-level ticket listings from [StubHub](https://www.stubhub.com) — concerts, sports, theater. Returns section, row, seat range, quantity, price, fees, face value and ticket class for every listing on an event, plus an event record with venue, date and lowest price.

Not the ten listings the page shows you. All of them.

---

### StubHub Ticket Resale Scraper Features

- Returns **every listing on an event**, not the curated handful the page renders. One Los Angeles Dodgers game came back with 552 listings across 58 pages.
- Extracts 30+ fields per listing — section, row, seat range, available quantity, raw price, fees, face value, ticket class, plus StubHub's own star rating, deal score and seat-quality score.
- Stable `listing_id` per seller listing, so you can diff two runs and see exactly what moved.
- Discovers events from any performer, team or venue page. Point it at `/new-york-yankees-tickets` and it finds the schedule itself.
- `eventsOnly` mode returns just the event rows with lowest price. Much cheaper when you only want to know what is on sale and roughly what it costs.
- Works across every category. Concerts, MLB, NFL, theater — the extraction does not care what you point it at.
- Fails loudly on an empty result instead of billing you for a run that returned nothing.

---

### What Can You Do With StubHub Listing Data?

- **Ticket resellers** — Watch an event's inventory and pricing across runs, and see which sections are thinning out before the price moves.
- **Price monitors** — Diff `listing_id` between runs to catch new listings, price drops and sold-out sections without re-reading the whole market.
- **Market analysts** — Compare face value against asking price by section to measure markup across venue, category or day of week.
- **Event aggregators** — Pull a performer's schedule and lowest price with `eventsOnly`, then drill into the events that matter.
- **Venue and promoter analysts** — Track secondary-market depth for your own events, which is the number nobody hands you.

Two jobs show up in how people actually use ticket scrapers, and this one is built for both. Some run a single event on a schedule and want every listing — that is monitoring, and it needs full inventory and a stable id to diff on. Others run once across many events and only want the headline price — that is research, and it needs `eventsOnly` and a small bill.

---

### How StubHub Ticket Resale Scraper Works

StubHub does not put its inventory in the page source. The event HTML carries event metadata and a lowest price; the listings arrive separately once the page is running, behind AWS WAF and DataDome.

So the scraper runs a real browser, clears the challenge, then walks the listing grid page by page from inside that cleared session. Ten listings per page, however many pages the event has. It stops when the event runs out, not when the page stops scrolling.

Residential mobile egress, because that is what the site's bot protection lets through. If an exit gets refused it draws a fresh one and carries on.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | `50` | Maximum records to return, counting both event and listing rows. |
| `discoverUrl` | string | — | Performer, team or venue page to pull events from. Example: `https://www.stubhub.com/new-york-yankees-tickets` |
| `eventUrls` | array | — | Specific StubHub event URLs. Overrides `discoverUrl` when set. |
| `quantity` | integer | `1` | Only return listings that can sell this many tickets together. |
| `eventsOnly` | boolean | `false` | Return event rows without their listings. The cheap way to browse what is on sale. |

Supply either `discoverUrl` or `eventUrls`. Supplying neither is the one way to make it complain immediately.

---

### StubHub Ticket Resale Scraper Output Fields

Every row carries `record_type` — `event` for an event summary, `listing` for a seller listing.

#### Event rows

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `event` on these rows |
| `event_id` | string | StubHub event id |
| `event_url` | string | Canonical event page URL |
| `event_title` | string | Event name, e.g. Seattle Mariners at Los Angeles Dodgers |
| `event_date_utc` | string | Start date and time, ISO 8601 |
| `venue_name` | string | Venue name |
| `venue_city` | string | Venue city |
| `venue_state` | string | State or region |
| `venue_country` | string | Country |
| `category` | string | StubHub category for the event |
| `lowest_price` | number | Lowest advertised price across the event |
| `price_currency` | string | Currency of `lowest_price` |
| `availability` | string | schema.org availability |
| `category_id` | string | StubHub numeric category id |

#### Listing rows

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `listing` on these rows |
| `listing_id` | string | Unique per seller listing. This is the one you diff on. |
| `section` | string | Seating section label, e.g. `30RS` |
| `section_id` | integer | Numeric section id |
| `section_map_name` | string | Section name as shown on the seat map |
| `row` | string | Row within the section |
| `seat_from` | string | First seat number |
| `seat_to` | string | Last seat number |
| `available_tickets` | integer | Tickets available in this listing |
| `available_quantities` | string | Quantities the seller will split to, e.g. `1,2,4` |
| `max_quantity` | integer | Largest purchasable quantity |
| `price` | number | Raw per-ticket price |
| `formatted_price` | string | Per-ticket price as displayed |
| `formatted_total_price` | string | Total price as displayed |
| `formatted_fees` | string | Fees, when broken out |
| `face_value` | number | Face value, when the seller discloses it |
| `listing_currency` | string | Currency the listing is priced in |
| `ticket_class` | string | Ticket class, e.g. Infield Reserve |
| `ticket_type` | string | Ticket type name |
| `listing_notes` | string | Seller and site notes, e.g. `Clear view` |
| `star_rating` | integer | StubHub star rating |
| `deal_score` | string | StubHub deal score |
| `seat_quality_score` | string | StubHub seat quality score |
| `is_seated_together` | boolean | Whether the seats are together |
| `is_zone_ticket` | boolean | Zone seating rather than specific seats |
| `is_cheapest` | boolean | Flagged as the cheapest listing |
| `is_better_value` | boolean | Flagged as better value |
| `is_sponsored` | boolean | Promoted listing |
| `listing_url` | string | Deep link to the listing |
| `scraped_at` | string | ISO 8601 scrape timestamp |

Listing rows repeat `event_id`, `event_title`, `event_date_utc`, `venue_name` and `venue_city`, so a listing stands on its own without a join.

---

### FAQ

#### How many listings does it actually return?

However many the event has. A single Los Angeles Dodgers game returned 552 unique listings across 58 pages. The event page itself shows ten, which is where most tools stop.

#### Can I track price changes over time?

Yes, and that is what `listing_id` is for. Run it on a schedule, keep the results, and diff on `listing_id` — new ids are new listings, missing ids have sold or been pulled, and a changed `price` on the same id is a repricing.

#### What is the difference between `price` and `face_value`?

`price` is what the seller is asking per ticket. `face_value` is what was originally printed on it, when the seller discloses it — often they do not. The gap between the two is the markup, which is usually the interesting part.

#### Why do some listings have no seat numbers?

Zone listings. When `is_zone_ticket` is true the seller is selling into a general area rather than specific seats, so `seat_from` and `seat_to` are empty and `section` is the granularity you get.

#### Can I scrape an event that has already happened?

No, and neither can anyone else. StubHub delists past events, so there is nothing on the page to scrape. The actor says so rather than handing back an empty dataset.

#### Do I need my own proxies?

No. Residential egress is handled for you, including drawing a fresh exit when one gets refused.

---

### Need More Features?

Open a request at [orbtop.com](https://orbtop.com) — extra filters, new discovery entry points, and scheduled delivery are all on the table. Specifics help more than "it should do more".

---

### Why Use StubHub Ticket Resale Scraper?

- **Full inventory, not a sample** — 552 listings on an event whose page renders ten. If you are pricing against the market, you need the market.
- **Seat-level detail** — Section, row, seat range and quantity, plus face value and StubHub's own deal and seat-quality scores.
- **Built for repeat runs** — A stable `listing_id` makes diffing two runs trivial, which is what monitoring actually requires.
- **A cheap mode that is genuinely cheap** — `eventsOnly` skips the listing walk entirely when you only need the schedule and the headline price.
- **Honest failures** — A run that returns nothing raises an error explaining why, instead of handing you an empty dataset and a bill.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.
## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.
## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.
## `maxItems` (type: `integer`):

Maximum records to return, counting both event and listing rows.
## `discoverUrl` (type: `string`):

Performer, team or venue page to pull events from. Example: https://www.stubhub.com/new-york-yankees-tickets
## `eventUrls` (type: `array`):

Specific StubHub event URLs to scrape. Overrides the discovery page when set.
## `quantity` (type: `integer`):

Only return listings that can sell this many tickets together.
## `eventsOnly` (type: `boolean`):

Return event records without their ticket listings. Much cheaper for browsing what is on sale.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 50,
  "discoverUrl": "https://www.stubhub.com/new-york-yankees-tickets",
  "quantity": 1,
  "eventsOnly": false
}
````

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 50,
    "discoverUrl": "https://www.stubhub.com/new-york-yankees-tickets",
    "quantity": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/stubhub-ticket-resale-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 50,
    "discoverUrl": "https://www.stubhub.com/new-york-yankees-tickets",
    "quantity": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/stubhub-ticket-resale-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 50,
  "discoverUrl": "https://www.stubhub.com/new-york-yankees-tickets",
  "quantity": 1
}' |
apify call jungle_synthesizer/stubhub-ticket-resale-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StubHub Ticket Resale Scraper",
        "description": "Scrape seller-level ticket resale listings from StubHub — concerts, sports and theater. Returns section, row, seat range, quantity, price, fees, face value and ticket class per listing, plus an event record with venue, date and lowest price.",
        "version": "1.0",
        "x-build-id": "Gnsau9ZJseuAaIBEM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~stubhub-ticket-resale-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-stubhub-ticket-resale-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~stubhub-ticket-resale-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-stubhub-ticket-resale-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~stubhub-ticket-resale-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-stubhub-ticket-resale-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": [
                    "maxItems"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "What will this data feed? E.g. lead lists, KYB checks, price tracking."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact email (optional)",
                        "minLength": 1,
                        "type": "string",
                        "description": "We'll personally help with your use case. No spam."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum records to return, counting both event and listing rows.",
                        "default": 50
                    },
                    "discoverUrl": {
                        "title": "Discover events from a page",
                        "type": "string",
                        "description": "Performer, team or venue page to pull events from. Example: https://www.stubhub.com/new-york-yankees-tickets"
                    },
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "Specific StubHub event URLs to scrape. Overrides the discovery page when set.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "quantity": {
                        "title": "Ticket quantity",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only return listings that can sell this many tickets together.",
                        "default": 1
                    },
                    "eventsOnly": {
                        "title": "Events only",
                        "type": "boolean",
                        "description": "Return event records without their ticket listings. Much cheaper for browsing what is on sale.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```