# Udemy Course Reviews Scraper (`scrapelabsapi/udemy-course-reviews-scraper`) Actor

- **URL**: https://apify.com/scrapelabsapi/udemy-course-reviews-scraper.md
- **Developed by:** [ScrapeLabs](https://apify.com/scrapelabsapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Udemy Course Reviews Scraper

**Extract Udemy course reviews at scale with intelligent proxy management and real-time data collection**

Scrape Udemy course reviews efficiently with our powerful Apify Actor. Get structured review data including ratings, content, user information, and timestamps. Perfect for market research, competitor analysis, sentiment analysis, and course quality assessment.

### 🎯 Why Choose This Udemy Reviews Scraper?

Our Udemy course reviews scraper stands out with intelligent proxy fallback, live data saving, and robust error handling. Built for reliability and scale, it automatically handles rate limits and blocks while ensuring maximum data collection success.

#### Key Advantages

- **Zero Configuration Proxy Management**: Automatically switches from direct requests to datacenter proxies, then residential proxies if blocked
- **Live Data Saving**: Reviews are saved to Apify Dataset in real-time, so you never lose data even if the scraper stops
- **Bulk Processing**: Scrape multiple courses simultaneously with configurable concurrency
- **Comprehensive Data**: Extract ratings, review content, user profiles, timestamps, and more
- **Production-Ready**: Built with error handling, retry logic, and detailed logging

### ✨ Key Features

#### 🚀 Intelligent Proxy Fallback System

The scraper uses a smart three-tier proxy strategy:

1. **Direct Requests (Default)**: Starts with no proxy for maximum speed and cost efficiency
2. **Automatic Datacenter Fallback**: If Udemy blocks direct requests, automatically switches to datacenter proxies
3. **Residential Proxy Fallback**: If datacenter proxies are blocked, falls back to residential proxies with 3 retries
4. **Sticky Residential Mode**: Once residential proxy is used, it becomes sticky for all remaining requests to ensure consistency

#### 📊 Complete Review Data Extraction

Extract comprehensive review information:

- **Review Content**: Full text of each review
- **Ratings**: Star ratings (1.0 to 5.0)
- **User Information**: Display names, initials, profile images, tracking IDs
- **Timestamps**: Created, modified, and user-modified dates
- **Formatted Dates**: Human-readable time since posting (e.g., "2 weeks ago")
- **Course URLs**: Direct links to each course

#### ⚡ Performance & Reliability

- **Async Processing**: Concurrent scraping for multiple courses
- **Live Saving**: Data saved immediately to prevent loss
- **Error Handling**: Automatic retries with exponential backoff
- **Rate Limiting**: Built-in delays to respect Udemy's rate limits
- **Detailed Logging**: Track every step of the scraping process

### 📥 Input Configuration

#### Required Fields

- **urls** (array): List of Udemy course URLs to scrape
  - Example: `["https://www.udemy.com/course/100-days-of-code/"]`
  - Supports full URLs or course slugs

#### Optional Fields

- **maxItems** (integer): Maximum number of reviews to fetch per course
  - Default: `10`
  - Minimum: `1`
  - Set to `null` to fetch all available reviews

- **proxyConfiguration** (object): Proxy settings
  - Default: No proxy (direct requests)
  - Auto-fallback to datacenter then residential if blocked
  - Configure Apify proxy groups if needed

#### Input Example

```json
{
  "urls": [
    "https://www.udemy.com/course/100-days-of-code/",
    "https://www.udemy.com/course/python-for-data-science/"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format

Each review is saved as a structured JSON object with the following fields:

```json
{
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "class": "course_review",
  "id": 223523111,
  "content": "I had never known how to code and did not know it was something that would really catch my interest...",
  "rating": 5.0,
  "created": "2025-12-07T09:46:39-08:00",
  "modified": "2025-12-08T15:13:23-08:00",
  "user_modified": "2025-12-07T09:50:58-08:00",
  "user": {
    "_class": "user",
    "title": "Aralyn Violet Sassenberg",
    "name": "Aralyn Violet",
    "display_name": "Aralyn Violet Sassenberg",
    "image_50x50": "https://img-c.udemycdn.com/user/50x50/anonymous_3.png",
    "initials": "AS",
    "tracking_id": "ULJIYFkwR22D5dVDaF4sVQ",
    "public_display_name": "Aralyn Violet S."
  },
  "created_formatted_with_time_since": "a week ago"
}
```

#### Output Fields Explained

- **courseUrl**: Full URL of the course being reviewed
- **class**: Type identifier (always "course\_review")
- **id**: Unique review ID
- **content**: Full text content of the review
- **rating**: Numeric rating from 1.0 to 5.0
- **created/modified/user\_modified**: ISO 8601 timestamps
- **user**: Reviewer information (name, display\_name, image\_50x50, initials, tracking\_id, public\_display\_name)
- **created\_formatted\_with\_time\_since**: Human-readable time since posting

### 🚀 How to Use the Actor

#### Via Apify Console

1. **Navigate to Actors**: Log in at <https://console.apify.com> and go to the **Actors** section

2. **Find the Actor**: Search for "udemy-course-reviews-scraper" or locate it in your actor list

3. **Configure Input**:
   - Add Udemy course URLs in the `urls` field
   - Set `maxItems` to limit reviews per course (optional)
   - Configure proxy settings if needed (optional)

4. **Run the Actor**: Click **Start** to begin scraping

5. **Monitor Progress**: Watch real-time logs showing:
   - Proxy status (DIRECT, DATACENTER, RESIDENTIAL)
   - Pages being scraped
   - Reviews collected
   - Any errors or fallbacks

6. **Access Results**:
   - Go to the **Dataset** tab to view scraped reviews
   - Export data as JSON, CSV, or Excel
   - Use the API to integrate with your applications

#### Via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://www.udemy.com/course/100-days-of-code/"],
    "maxItems": 100
  }'
```

#### Via Apify SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR_ACTOR_ID").call(
    run_input={
        "urls": ["https://www.udemy.com/course/100-days-of-code/"],
        "maxItems": 100
    }
)

## Wait for run to finish
client.run(run["data"]["id"]).wait_for_finish()

## Get results
dataset_items = client.dataset(run["data"]["defaultDatasetId"]).list_items()
```

### 💼 Best Use Cases

#### Market Research & Competitive Analysis

Analyze competitor courses by scraping their reviews to understand:

- What students like and dislike
- Common pain points and complaints
- Feature requests and suggestions
- Rating trends over time

#### Sentiment Analysis & NLP Projects

Collect large datasets of review text for:

- Sentiment analysis models
- Natural language processing research
- Text classification training data
- Opinion mining projects

#### Course Quality Assessment

Evaluate course quality by analyzing:

- Average ratings across multiple courses
- Review content patterns
- User engagement metrics
- Time-based review trends

#### Data Science & Analytics

Build datasets for:

- Machine learning model training
- Statistical analysis of course performance
- Trend identification and forecasting
- Academic research projects

#### Business Intelligence

Gain insights for:

- Course pricing strategies
- Content improvement opportunities
- Market positioning analysis
- Customer satisfaction tracking

### ❓ Frequently Asked Questions

#### How many reviews can I scrape?

There's no hard limit. Set `maxItems` to control how many reviews per course, or leave it unset to scrape all available reviews. The scraper handles pagination automatically.

#### Will I get blocked by Udemy?

The scraper includes intelligent proxy fallback to minimize blocks:

- Starts with direct requests (fastest, no cost)
- Automatically switches to proxies if blocked
- Uses residential proxies as final fallback
- Includes rate limiting and delays

#### How long does scraping take?

Scraping speed depends on:

- Number of courses
- Reviews per course
- Proxy mode (direct is fastest)
- Rate limits encountered

Typically, 100 reviews take 1-3 minutes with direct requests.

#### Can I scrape private courses?

No. This scraper only accesses publicly available review data. Private or restricted courses cannot be scraped.

#### What happens if the scraper stops?

All successfully scraped reviews are saved to the Apify Dataset in real-time. Even if the scraper stops, you won't lose data that was already collected.

#### Do I need to configure proxies?

No. The scraper defaults to direct requests (no proxy). It automatically falls back to proxies only if needed. You can optionally configure proxy settings in the input.

#### Can I scrape multiple courses at once?

Yes! Add multiple URLs to the `urls` array. The scraper processes them concurrently for maximum efficiency.

#### What data format is the output?

Reviews are saved as JSON objects in the Apify Dataset. You can export to JSON, CSV, Excel, or access via API.

#### Is the scraper legal?

This scraper only accesses publicly available review data. You are responsible for ensuring compliance with:

- Terms of service of Udemy
- Local data protection laws (GDPR, CCPA, etc.)
- Anti-spam regulations
- Any applicable privacy laws

Always review and comply with Udemy's Terms of Service and robots.txt before scraping.

### ⚠️ Important Notes & Cautions

#### Legal Compliance

- **Public Data Only**: Collects only publicly available review data
- **No Private Content**: Private accounts or restricted courses cannot be accessed
- **User Responsibility**: Ensure compliance with Udemy's Terms of Service, data protection laws (GDPR, CCPA), anti-spam regulations, and local privacy legislation

#### Rate Limiting & Data Accuracy

The scraper includes built-in delays to respect Udemy's rate limits. Aggressive scraping may trigger blocks, but automatic proxy fallback helps mitigate this. Review data is collected exactly as displayed on Udemy without modification or filtering.

### 📞 Support and Feedback

**💬 For custom solutions or feature requests, contact us at:** <dev.scraperengine@gmail.com>

#### Getting Help

- **Documentation**: Check this README for common questions
- **Apify Support**: Visit [Apify Support](https://apify.com/support) for platform-related issues
- **Actor Issues**: Report bugs or request features via email

We welcome feedback, feature requests, bug reports, and use case examples.

***

**Built with ❤️ for the Apify community**

*Last updated: 2025*

# Actor input Schema

## `urls` (type: `array`):

📚 Add one or more Udemy course URLs.\n\n✅ Example: https://www.udemy.com/course/100-days-of-code/\n\n💡 Tip: Add multiple URLs to scrape many courses in a single run.

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

📈 Set how many reviews to collect for each course URL.\n\n⚡ Lower value = faster runs. Higher value = deeper data.

## `proxyConfiguration` (type: `object`):

🌐 Proxy control for better reliability.\n\n🟢 Default: no proxy\n🔁 Auto-fallback: Datacenter → Residential if blocked\n\n✅ Recommended for large batches or strict networks.

## Actor input object example

```json
{
  "urls": [
    "https://www.udemy.com/course/100-days-of-code/"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.udemy.com/course/100-days-of-code/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/udemy-course-reviews-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 = {
    "urls": ["https://www.udemy.com/course/100-days-of-code/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/udemy-course-reviews-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 '{
  "urls": [
    "https://www.udemy.com/course/100-days-of-code/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapelabsapi/udemy-course-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Udemy Course Reviews Scraper",
        "version": "0.1",
        "x-build-id": "DHaplTPci3RWRkscl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~udemy-course-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-udemy-course-reviews-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/scrapelabsapi~udemy-course-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-udemy-course-reviews-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/scrapelabsapi~udemy-course-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-udemy-course-reviews-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": {
                    "urls": {
                        "title": "🔗 Course URLs",
                        "type": "array",
                        "description": "📚 Add one or more Udemy course URLs.\\n\\n✅ Example: https://www.udemy.com/course/100-days-of-code/\\n\\n💡 Tip: Add multiple URLs to scrape many courses in a single run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "🎯 Max Reviews Per Course",
                        "minimum": 1,
                        "type": "integer",
                        "description": "📈 Set how many reviews to collect for each course URL.\\n\\n⚡ Lower value = faster runs. Higher value = deeper data.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "🌐 Proxy control for better reliability.\\n\\n🟢 Default: no proxy\\n🔁 Auto-fallback: Datacenter → Residential if blocked\\n\\n✅ Recommended for large batches or strict networks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```