# Academy Sports + Outdoors Scraper (`parseforge/academy-sports-outdoors-scraper`) Actor

Scrape Academy Sports + Outdoors product data at scale. Extract prices, ratings, reviews, stock availability, specifications, UPC codes, brand info, and free shipping details from any category or search page. Export clean, structured data as JSON, CSV, or Excel — ready for analysis.

- **URL**: https://apify.com/parseforge/academy-sports-outdoors-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

## 🏀 Academy Sports + Outdoors Scraper

Pull real product data from Academy Sports + Outdoors without writing a single line of code. Prices, discounts, stock status, ratings, specs, and more across 900,000+ sporting goods, outdoor gear, and apparel items, delivered in seconds.

> **The Academy Sports + Outdoors Scraper extracts live product data including prices, ratings, and inventory status from over 900,000 items. Filter by brand, category, price range, or deals.**

### ✨ What Does It Do

- 🖼️ **Product Image** - collect the main product photo for each item to use in catalogs, comparisons, or visual databases
- 💰 **Sale Price and Original Price** - track current prices alongside original prices to identify discount depth and spot clearance opportunities
- 🔥 **Hot Deal and Clearance Badges** - filter items tagged as Hot Deals or Clearance to find buying opportunities before they sell out
- ✅ **Stock and Inventory Status** - know exactly which items are in stock, low stock, or out of stock at the time of your run
- 🚚 **Free Shipping Eligibility** - see which products qualify for free shipping to factor total cost into purchasing decisions
- ⭐ **Ratings and Review Count** - compare customer satisfaction scores across products to prioritize high-performing inventory
- 🔩 **Product Specifications and Features** - extract detailed specs, features, and benefits to build comparison tables or enrich product feeds
- 🏪 **Store Availability Count** - see how many Academy store locations carry each product
- 🏷️ **Brand and Category** - segment data by brand or category to monitor competitors or analyze specific product lines

### 🔧 Input

- **Product URL** - paste a single Academy product URL to collect data for one item. Overrides all filters
- **Max Items** - number of products to collect. Free users: up to 100. Paid users: up to 1,000,000. Default: 10
- **Search Query** - full text search across all products (e.g. "running shoes", "fishing rod", "camping tent")
- **Brand** - filter by brand name (e.g. "Nike", "Under Armour", "Columbia")
- **Category** - filter by category path (e.g. "sports", "outdoors", "mens > mens-footwear")
- **Min / Max Price** - narrow results to a price band in USD
- **Hot Deals Only** - return only products currently marked as Hot Deals
- **Clearance Only** - return only clearance items
- **In Stock Only** - return only products currently in stock

Example input:
```json
{
  "searchQuery": "running shoes",
  "brand": "Nike",
  "maxItems": 50,
  "inStockOnly": true
}
````

### 📊 Output

Each product contains up to 20 fields. Download as JSON, CSV, or Excel.

| 🖼️ Product image | 📝 Title and description | 🏷️ Brand and category |
|---|---|---|
| 💰 Sale price | 📉 Original price and discount | 🔥 Hot Deal or Clearance badge |
| ✅ In stock status | 🚚 Free shipping eligibility | ⭐ Rating and review count |
| 🔩 Product specifications | 📋 Features and benefits | 📦 UPC code |
| 🏪 Store availability count | 🆔 SKU and product ID | 🔗 Direct product URL |

```json
{
  "imageUrl": "https://academy.scene7.com/is/image/academy/...",
  "title": "Nike Men's Revolution 8 Running Shoe",
  "brand": "Nike",
  "category": "Men's > Men's Footwear > Athletic Shoes > Running Shoes",
  "price": 49.99,
  "originalPrice": 74.99,
  "discount": "33% off",
  "badge": "Hot Deal",
  "inStock": true,
  "inventoryStatus": "In Stock",
  "freeShipping": false,
  "rating": 4.5,
  "reviewCount": 284,
  "description": "Hit the pavement with supportive cushioning...",
  "specifications": { "Closure": ["Lace"], "Activity": ["Running"] },
  "featureBenefits": ["Lightweight mesh upper", "Foam midsole for cushioning"],
  "upc": "195867423810",
  "storeCount": 183,
  "sku": "NVRT01234",
  "productId": "132105789",
  "url": "https://www.academy.com/p/nike-mens-revolution-8-running-shoe",
  "scrapedAt": "2026-03-18T14:30:00.000Z"
}
```

### 💎 Why Choose the Academy Sports + Outdoors Scraper?

| Feature | Our Actor |
|---|---|
| Live prices, discounts, and stock status | ✔️ |
| 900,000+ products across the full catalog | ✔️ |
| No proxy required | ✔️ |
| Filter by brand, category, price, or deal type | ✔️ |
| Hot Deals and Clearance filters | ✔️ |
| Free shipping flag per product | ✔️ |
| Product specs and features | ✔️ |
| Store availability count | ✔️ |
| Ratings and review counts | ✔️ |
| UPC codes for inventory matching | ✔️ |
| Free tier: 100 results per run | ✔️ |
| Export as CSV, Excel, or JSON | ✔️ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up**: [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool**: Search for "Academy Sports + Outdoors Scraper" in the Apify Store and set your input
3. **Run It**: Click "Start" and view your results

That's it. No coding, no setup, no complicated configuration. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Competitive Analyst** - monitor prices, discounts, and stock across 900K products to spot trends in pricing strategy and identify high margin categories
- 💼 **Retail Buyer** - filter by brand or category to track new arrivals, clearance patterns, and availability across Academy's store network
- 🔬 **Data Researcher** - build structured datasets of sporting goods products with specs, ratings, and pricing for market analysis or ML training
- 🛒 **E-commerce Seller** - track competitor prices on specific brands, monitor Hot Deals, and find clearance buying opportunities

### ❓ FAQ

**🔍 How does it work?**
It collects publicly available product data from Academy's website and delivers it in structured format. No coding or technical setup required.

**📊 How accurate is the data?**
Data reflects live prices, stock, and availability at the time of the run.

**📅 Can I schedule this to run automatically?**
Yes, use Apify's scheduling feature or integrate with platforms like Make or Zapier for scheduled runs.

**⚖️ Is it legal to collect Academy Sports data?**
This tool collects publicly available catalog data. Users must comply with Academy's terms of service and applicable local laws.

**🛡️ Will Academy Sports block me?**
No proxy is needed. The actor collects publicly available product data and is designed to avoid disrupting the site.

**⚡ How long does a run take?**
Around 5,000 products can be collected in under 30 seconds. Individual product lookups typically complete in under 5 seconds.

**⚠️ Are there any limits?**
Free users can collect up to 100 results per run. Paid users can collect up to 1,000,000 per run. A single query returns up to 5,000 products. Use brand or category filters to target specific subsets.

### 🎬 Demo Video

Demo video coming soon.

### 🔗 Integrate Academy Sports + Outdoors Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Carparts.com Scraper](https://apify.com/parseforge/carparts-com-scraper) - extract car parts inventory and pricing data
- [Cars For Sale Scraper](https://apify.com/parseforge/cars-for-sale-scraper) - collect used and new car listings with full details
- [Heads Up For Tails Scraper](https://apify.com/parseforge/heads-up-for-tails-scraper) - pull pet product catalog data
- [Mercari Scraper](https://apify.com/parseforge/mercari-scraper) - collect product listings and prices from Mercari marketplace
- [Etsy Scraper](https://apify.com/parseforge/etsy-scraper) - extract product data and shop information from Etsy

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Academy Sports + Outdoors or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

Direct URL to a single Academy product page (e.g. academy.com/p/nike-mens-revolution-8). When provided, all filters below are ignored.

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

Free users: Limited to 100. Paid users: Optional, max 1,000,000.

## `searchQuery` (type: `string`):

Full-text search across all products (e.g. 'running shoes', 'fishing rod', 'camping tent').

## `brand` (type: `string`):

Filter by brand name (e.g. 'Nike', 'Under Armour', 'Columbia', 'Magellan Outdoors').

## `categoryPath` (type: `string`):

Filter by category path (e.g. 'sports', 'outdoors', 'outdoors > shooting', 'mens > mens-footwear').

## `minPrice` (type: `number`):

Minimum product price in USD.

## `maxPrice` (type: `number`):

Maximum product price in USD.

## `hotDealsOnly` (type: `boolean`):

Only return products marked as Hot Deals.

## `clearanceOnly` (type: `boolean`):

Only return clearance items.

## `inStockOnly` (type: `boolean`):

Only return products currently in stock.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "running shoes",
  "hotDealsOnly": false,
  "clearanceOnly": false,
  "inStockOnly": false
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "maxItems": 10,
    "searchQuery": "running shoes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/academy-sports-outdoors-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 = {
    "maxItems": 10,
    "searchQuery": "running shoes",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/academy-sports-outdoors-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 '{
  "maxItems": 10,
  "searchQuery": "running shoes"
}' |
apify call parseforge/academy-sports-outdoors-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Academy Sports + Outdoors Scraper",
        "description": "Scrape Academy Sports + Outdoors product data at scale. Extract prices, ratings, reviews, stock availability, specifications, UPC codes, brand info, and free shipping details from any category or search page. Export clean, structured data as JSON, CSV, or Excel — ready for analysis.",
        "version": "1.0",
        "x-build-id": "0fmHyAsPJikn2v28e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~academy-sports-outdoors-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-academy-sports-outdoors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~academy-sports-outdoors-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-academy-sports-outdoors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~academy-sports-outdoors-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-academy-sports-outdoors-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",
                "properties": {
                    "startUrl": {
                        "title": "Product URL",
                        "type": "string",
                        "description": "Direct URL to a single Academy product page (e.g. academy.com/p/nike-mens-revolution-8). When provided, all filters below are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 100. Paid users: Optional, max 1,000,000."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Full-text search across all products (e.g. 'running shoes', 'fishing rod', 'camping tent')."
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Filter by brand name (e.g. 'Nike', 'Under Armour', 'Columbia', 'Magellan Outdoors')."
                    },
                    "categoryPath": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter by category path (e.g. 'sports', 'outdoors', 'outdoors > shooting', 'mens > mens-footwear')."
                    },
                    "minPrice": {
                        "title": "Min Price ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum product price in USD."
                    },
                    "maxPrice": {
                        "title": "Max Price ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum product price in USD."
                    },
                    "hotDealsOnly": {
                        "title": "Hot Deals Only",
                        "type": "boolean",
                        "description": "Only return products marked as Hot Deals.",
                        "default": false
                    },
                    "clearanceOnly": {
                        "title": "Clearance Only",
                        "type": "boolean",
                        "description": "Only return clearance items.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In Stock Only",
                        "type": "boolean",
                        "description": "Only return products currently in stock.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```