# Usa Fitness Leads Hub (`b2b_lead_generation/usa-fitness-leads-hub`) Actor

Filter and extract leads from US gyms, sports clubs, yoga studios, and personal trainers. Export verified business names, phones, websites, and emails instantly.

- **URL**: https://apify.com/b2b\_lead\_generation/usa-fitness-leads-hub.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.99 / 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.

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

## USA Fitness Leads Hub 💼✨

<p align="center">
  <img src="https://imgur.com/zz6D6Y8.png" alt="USA Automotive Leads Hub" style="max-width:100%; border-radius:14px; width:680px;" />
</p>


#### ⚡ Instant USA Fitness, Gyms & Sports Leads Extractor
Deploy a state-of-the-art retrieval solution to target and extract **American fitness, sports, and active lifestyle business contacts** across specialized sectors. Powered by an ultra-fast indexing engine, this extractor delivers instant access to verified business names, direct contact phones, email addresses, websites, and complete physical locations.

Whether you need to build local business contact directories or fuel enterprise-level B2B sales pipelines, you can define your target fitness categories, apply precise registry filters, and generate ready-to-use lists in seconds.

---

### 🎯 Key Capabilities

* **Target Any Active Niche**: Search commercial gyms, boutique yoga studios, rock climbing centers, martial arts academies, and canine athletic trainers.
* **Granular Registry Sector Filters**: Narrow down searches by targeting specific commercial directories independently (e.g., `Gyms`, `Yoga_Studio`, `Martial_Arts_Studios`, `Rock_Climbing_Gym`, `Dog_trainers`).
* **Multi-Category Parallel Search**: Input multiple target terms simultaneously. The extractor searches each term sequentially and builds a single, deduplicated export.
* **Flexible Matching Engine**: Toggle between broad substring matching (e.g., `yoga` matches `Yoga Studio` and `Power Yoga LLC`) or precise full-word boundary matching.
* **Custom Extraction Limits**: Pull a fast sample of 100 listings or run a comprehensive campaign extraction up to 10,000 records.
* **Zero-Hassle Export Formats**: Download clean, structured datasets in CSV, Excel, or JSON format directly from your Apify Console.

---

### 💼 High-Impact Use Cases

* **B2B Professional Sales & Outreach**: Identify high-value gym owners, wellness directors, martial arts masters, and program coordinators matching your ideal customer profile (ICP).
* **Cold Email & Marketing Campaigns**: Feed your marketing sequences with clean, verified email addresses mapped to specific US fitness and wellness niches.
* **Equipment & SaaS Sales**: Discover local gyms, studios, and clubs in specific regions to pitch fitness equipment, scheduling software, insurance, or customized corporate wellness programs.
* **Market Mapping & Competitor Analysis**: Analyze the concentration and distribution of athletic facilities and wellness centers across US states and metropolitan areas.
* **Local Business Directories**: Build, enrich, or refresh local fitness, sports, and health finder directories and map apps with up-to-date business contact data.

---

### ⚙️ Input Configuration

The extractor accepts highly customizable, optional search criteria. For the best results, defining at least one category keyword or target registry sector is recommended.

#### Extraction Parameters

| Field Name | Type | Description |
|:---|:---|:---|
| `categories` | `array` | Category keywords to search within listing descriptions (one per line). Supports partial terms (e.g., `trainer` matches `Personal trainer`, `Dog trainer`). Case-insensitive. |
| `sourceCategories` | `array` | Specific commercial registry sectors to filter by (e.g., `Gyms`, `Yoga_Studio`, `Martial_Arts_Studios`, `Rock_Climbing_Gym`, `Dog_trainers`). Limits extraction to listings matching these primary directory sectors. |
| `matchType` | `select` | Choose match style: `any_character` (flexible substring search) or `full_word` (exact word boundaries to reduce search noise). Default: `any_character`. |
| `limit` | `integer` | Maximum number of records to return. Min: `100`, Max: `10,000`, Default: `500`. |

---

#### Example Configurations

##### 🔹 Scenario A: Simple Sector Extraction
Extract listings from a single active commercial sector.
```json
{
    "sourceCategories": ["Gyms"],
    "matchType": "any_character",
    "limit": 500
}
````

##### 🔹 Scenario B: Multi-Sector Lead Generation

Compile contacts from multiple diverse active registries.

```json
{
    "sourceCategories": ["Yoga_Studio", "Martial_Arts_Studios"],
    "matchType": "any_character",
    "limit": 1000
}
```

##### 🔹 Scenario C: Hyper-Targeted Search

Combine specific text search queries with registry filters using precise full-word matching.

```json
{
    "categories": ["Personal trainer", "Obedience training"],
    "sourceCategories": ["Dog_trainers"],
    "matchType": "full_word",
    "limit": 500
}
```

***

### 📊 Extracted Output Format

Every record retrieved by the extractor represents a verified US commercial business listing. Results are delivered in real-time to your dataset.

#### Sample JSON Output

```json
{
    "name": "DOG's Athletic Performance LLC",
    "categories": "Gym",
    "phone": "+19564518859",
    "email": "contact@dogsathletic.com",
    "address": "420 S Texas Blvd, Weslaco, TX 78596, United States",
    "website": "http://www.dogsathletic.com/",
    "source_category": "Dog_trainers",
    "scrapedAt": "2026-06-07T12:00:36.000Z"
}
```

#### Output Field Descriptions

| Column Name | Type | Description |
|:---|:---|:---|
| `name` | `string` | Registered business or professional practitioner name. |
| `categories` | `string` | Semicolon-separated categories describing the firm's services. |
| `phone` | `string` | Contact phone number in standardized international format. |
| `email` | `string` | Direct contact email address (where publicly available). |
| `address` | `string` | Complete physical mailing address including city, state, and ZIP. |
| `website` | `string` | Verified URL of the business website. |
| `source_category` | `string` | The parent registry sector from which the listing was retrieved. |
| `scrapedAt` | `string` | ISO UTC timestamp recording when the listing was extracted. |

***

### 📂 Sourced Directory Sectors

Target these primary directory sectors inside `sourceCategories` or use them as search keywords in the `categories` input list.

#### 🏋️ Gyms & Health Clubs

- `Gyms`: Traditional health clubs, fitness centers, training academies, and athletic conditioning facilities.

#### 🧘 Yoga & Wellness

- `Yoga_Studio`: Yoga instruction centers, Pilates studios, meditation spaces, and holistic wellness communities.

#### 🧗 Adventure & Extreme Sports

- `Rock_Climbing_Gym`: Indoor rock climbing centers, bouldering gyms, and outdoor adventure training guides.

#### 🥋 Martial Arts & Self-Defense

- `Martial_Arts_Studios`: Karate, Jiu-Jitsu, Taekwondo, boxing gyms, and tactical self-defense schools.

#### 🐕 Canine Athletics & Training

- `Dog_trainers`: Service trainers, canine agility coaches, obedience training camps, and puppy academies.

***

#### 🔗 Comprehensive Category Reference

For a complete listing of all indexed registry categories, refer to the online index:
👉 [All USA Fitness & Sports Services Categories Directory](https://github.com/kawsarlog/automatic-text/blob/main/USA%20Fitness%20Leads%20Hub.txt)
--------------------------------------------------------------------------------------------------------------------------------------------------

### 🗺️ Geographic Distribution

The extraction engine indexes active fitness and athletic listings across all 50 US states. You can segment results geographically by downloading the dataset and sorting by state or zip code.

- **California (CA)**: Los Angeles, San Diego, San Jose, San Francisco, Sacramento, Oakland, Pasadena
- **Texas (TX)**: Houston, San Antonio, Dallas, Austin, Fort Worth, El Paso, Arlington, Weslaco
- **Florida (FL)**: Jacksonville, Miami, Tampa, Orlando, St. Petersburg, Lynn Haven, Panama City
- **Illinois (IL)**: Chicago, Aurora, Rockford, Joliet, Naperville, South Beloit
- **Oregon (OR)**: Portland, Salem, Eugene, Hillsboro, Gresham, Keizer, Dallas

***

### 💡 Pro Extraction Tips

1. **Leverage Broad Terms**: Use broad root words in `categories` (e.g., `trainer`) to capture personal trainers, athletic coaches, pet trainers, and yoga instructors in one pass.
2. **Combine Sector Filters**: Enter multiple target sectors in `sourceCategories` to fetch overlapping athletic fields cleanly.
3. **Exact Word Matching**: If you receive unrelated results, switch `matchType` to `full_word` to enforce strict search boundaries.
4. **Export Clean Files**: Always run the extractor to your target limit, then download the resulting dataset and filter by state or email-presence inside Excel or Google Sheets.

***

### 🔄 Integrations & Pipelines

Pipe your retrieved fitness and athletic contacts directly into your active B2B software stacks using Apify Integrations:

- **Spreadsheets**: Sync directly with Google Sheets for real-time list building.
- **Workflows**: Connect via Zapier or Make to trigger outbound emails automatically.
- **CRMs**: Stream listings straight into Salesforce, HubSpot, or Pipedrive.
- **Webhooks**: Fire webhooks the instant an extraction run completes.

<p align="center">
  <img src="https://imgur.com/djVqHX4.png" alt="USA Automotive Leads Hub" style="max-width:100%; border-radius:14px; width:680px;" />
</p>

***

### ❓ Frequently Asked Questions

> **Why do some records lack email addresses?**
> Email addresses are only extracted when publicly listed by the business. For listings without an email, the phone number, full address, and website URL are provided, which are ideal for alternative multichannel outreach.

> **Why did my run finish with fewer results than the limit?**
> The extractor only stops when it reaches your requested limit OR when it runs out of matching listings in the directory index. If a specific keyword has listings and your limit is set higher, you will receive exactly the matching listings. Try using broader keywords to expand coverage.

> **Can I search multiple categories at once?**
> Yes. Use the `categories` or `sourceCategories` fields and enter one keyword per line. The platform searches each in sequence and merges all results into a single dataset run.

> **Do I need to configure proxy settings?**
> No proxy configuration is required. The extractor runs against a fully indexed local dataset engine, delivering high performance and instant retrieval without IP blocks or scraping delays.

# Actor input Schema

## `categories` (type: `array`):

Category keywords to search within listing descriptions (one per line). Supports partial terms (e.g., 'trainer' matches 'Personal trainer', 'Athletic trainer'). Case-insensitive.

## `sourceCategories` (type: `array`):

Specific fitness and sports registry sectors to filter by (e.g., 'Gyms', 'Yoga\_Studio', 'Dog\_trainers'). Limits extraction to listings matching these primary directory sectors.

## `matchType` (type: `string`):

Choose match style: 'Any character match (substring)' for broad matching, or 'Full word match (word boundaries)' to reduce search noise.

## `limit` (type: `integer`):

Maximum number of filtered records to return. Min: 100, Max: 10,000.

## Actor input object example

```json
{
  "categories": [
    "Gym",
    "Yoga Studio"
  ],
  "matchType": "any_character",
  "limit": 500
}
```

# 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 = {
    "categories": [
        "Gym",
        "Yoga Studio"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/usa-fitness-leads-hub").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 = { "categories": [
        "Gym",
        "Yoga Studio",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/usa-fitness-leads-hub").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 '{
  "categories": [
    "Gym",
    "Yoga Studio"
  ]
}' |
apify call b2b_lead_generation/usa-fitness-leads-hub --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b2b_lead_generation/usa-fitness-leads-hub",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Usa Fitness Leads Hub",
        "description": "Filter and extract leads from US gyms, sports clubs, yoga studios, and personal trainers. Export verified business names, phones, websites, and emails instantly.",
        "version": "0.0",
        "x-build-id": "UPuOAo2poUaA6H3F3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~usa-fitness-leads-hub/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-usa-fitness-leads-hub",
                "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/b2b_lead_generation~usa-fitness-leads-hub/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-usa-fitness-leads-hub",
                "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/b2b_lead_generation~usa-fitness-leads-hub/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-usa-fitness-leads-hub",
                "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": {
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Category keywords to search within listing descriptions (one per line). Supports partial terms (e.g., 'trainer' matches 'Personal trainer', 'Athletic trainer'). Case-insensitive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceCategories": {
                        "title": "Source categories / Registry sectors",
                        "type": "array",
                        "description": "Specific fitness and sports registry sectors to filter by (e.g., 'Gyms', 'Yoga_Studio', 'Dog_trainers'). Limits extraction to listings matching these primary directory sectors.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "matchType": {
                        "title": "Matching mode",
                        "enum": [
                            "any_character",
                            "full_word"
                        ],
                        "type": "string",
                        "description": "Choose match style: 'Any character match (substring)' for broad matching, or 'Full word match (word boundaries)' to reduce search noise.",
                        "default": "any_character"
                    },
                    "limit": {
                        "title": "Result limit",
                        "minimum": 100,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of filtered records to return. Min: 100, Max: 10,000.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
