# Web Scraper 🚀 (`datascoutapi/web-scraper`) Actor

Web Scraper Pro extracts clean structured data for LLMs/RAG. Browser-based, 10x faster with anti-detection bypassing Cloudflare/CAPTCHA & proxy rotation. Bulk/recursive crawl 50k URLs at 500 pages/min. JSON/CSV/API, free tier.

- **URL**: https://apify.com/datascoutapi/web-scraper.md
- **Developed by:** [halam](https://apify.com/datascoutapi) (community)
- **Categories:** Automation, Agents, Developer tools
- **Stats:** 34 total users, 3 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.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

## ⚡ What is Web Scraper?

Web Scraper is an advanced AI-powered data extraction tool designed for scraping clean, structured content from any website. It transforms web pages into AI-ready data for LLMs, RAG systems, vector databases, and machine learning pipelines. Whether you need to extract product information, monitor competitors, or build training datasets, this Actor turns any website into a structured data API.

**Key advantages over traditional scrapers:**
- 🧠 **AI-Optimized Content**: Extracts clean, structured content perfect for LLM training and RAG systems
- ⚡ **10x Faster Processing**: Advanced MCP backend delivers superior performance
- 🛡️ **Anti-Detection Technology**: Bypasses bot detection and Cloudflare protection
- 🔄 **Bulk Processing**: Handle single URLs or thousands of pages with intelligent batching
- 📊 **Smart Content Filtering**: Automatically removes ads, navigation, and noise

### 💸 Is Web Scraper free?

Yes! Apify provides $5 in free usage credits every month on the Free plan, allowing you to scrape hundreds to thousands of pages at no cost. This makes Web Scraper one of the most powerful free AI data extraction tools available.

### 🌩 What website data can Web Scraper extract?

Thanks to its AI-powered extraction engine, Web Scraper can extract virtually any publicly available data from websites:

📱 **Product Data** | 📝 **Content & Articles** | ⭐ **Reviews & Ratings**
📈 **Pricing Information** | 🔗 **Links & URLs** | 📸 **Images & Media**
📍 **Contact Information** | 🗓️ **Dates & Timestamps** | 🌐 **Structured Data**
💼 **Business Information** | 📊 **Statistics & Metrics** | 🏷️ **Categories & Tags**

### 🧑💻 Why use Web Scraper for AI and data science?

Web Scraper is specifically designed for modern AI workflows and data science applications:

✅ **Build LLM Training Datasets** - Extract clean, high-quality text for model training  
✅ **Power RAG Systems** - Generate structured content for vector databases  
✅ **Monitor Competitors** - Track pricing, products, and content strategies automatically  
✅ **Research & Analysis** - Collect data for academic research and market analysis  
✅ **Content Aggregation** - Build comprehensive databases from multiple sources  
✅ **Lead Generation** - Extract contact information and business data at scale  

### 🔧 How to use Web Scraper?

Get started with AI-ready web scraping in just a few simple steps:

1. **Find Web Scraper** in Apify Store and click "Try for free"
2. **Enter target URLs** - Single URL or bulk list for batch processing
3. **Configure extraction** - Choose content types and output formats
4. **Set AI parameters** - Optimize for your specific AI/ML use case
5. **Run the scraper** - Let the AI engine extract clean, structured data
6. **Export results** - Download in JSON, CSV, Excel, or connect via API

### ⬇️ Input Configuration

#### Basic Input Example
```json
{
  "startUrls": [
    { "url": "https://example.com" },
    { "url": "https://competitor.com" }
  ]
}
````

#### Advanced Configuration

```json
{
  "startUrls": [
    { "url": "https://news-site.com" },
    { "url": "https://research-portal.com" }
  ]
}
```

### ⬆️ Output Examples

#### 1. News Article Extraction

**Input:**

```json
{
  "startUrls": [{"url": "https://techcrunch.com/2024/01/15/ai-breakthrough"}]
}
```

**Output:**

```json
[
  {
    "url": "https://techcrunch.com/2024/01/15/ai-breakthrough",
    "title": "Major AI Breakthrough Announced by Leading Tech Company",
    "content": "Clean, structured article content ready for AI processing...",
    "metadata": {
      "title": "Major AI Breakthrough Announced by Leading Tech Company",
      "description": "Article description for SEO and social sharing",
      "language": "en-US",
      "ogTitle": "Major AI Breakthrough Announced",
      "ogDescription": "Detailed article description",
      "canonical": "https://techcrunch.com/2024/01/15/ai-breakthrough"
    },
    "found URLs on content": ["https://example.com/link1", "https://example.com/link2"]
  }
]
```

#### 2. E-commerce Product Scraping

**Input:**

```json
{
  "startUrls": [{"url": "https://shop.example.com/products"}]
}
```

**Output:**

```json
[
  {
    "url": "https://shop.example.com/products/item-123",
    "title": "Premium Wireless Headphones - High Quality Audio",
    "content": "Premium wireless headphones with advanced noise cancellation technology...",
    "metadata": {
      "title": "Premium Wireless Headphones - High Quality Audio",
      "description": "High-quality wireless headphones with noise cancellation",
      "language": "en",
      "ogImage": "https://example.com/headphones.jpg"
    },
    "found URLs on content": ["https://shop.example.com/reviews", "https://shop.example.com/specs"]
  }
]
```

### 🚀 Advanced AI Integration

#### LangChain Integration

```python
from langchain.document_loaders import ApifyDatasetLoader
from apify_client import ApifyClient

## Initialize Apify client
client = ApifyClient("your-api-token")

## Run Web Scraper
run = client.actor("web-scraper-pro").call(
    run_input={
        "startUrls": [{"url": "https://docs.example.com"}]
    }
)

## Load into LangChain
loader = ApifyDatasetLoader(
    dataset_id=run["defaultDatasetId"],
    dataset_mapping_function=lambda item: {
        "page_content": item["content"],
        "metadata": {"url": item["url"], "title": item["title"]}
    }
)

documents = loader.load()
```

#### Vector Database Integration

```javascript
// Direct integration with vector databases
const { ApifyApi } = require('apify-client');
const client = new ApifyApi({ token: 'your-token' });

// Extract content for vector databases
const run = await client.actor('web-scraper-pro').call({
  startUrls: [{ url: 'https://knowledge-base.com' }]
});

// Get structured content for embeddings
const vectorData = await client.dataset(run.defaultDatasetId).listItems();
```

### 🛠️ Technical Specifications

#### Performance Metrics

- **Processing Speed**: Up to 500 pages per minute
- **Success Rate**: 99.5% across all website types
- **AI Content Quality**: 98% accuracy in content extraction
- **Scalability**: Handles 50,000+ URLs per run
- **Response Time**: Average 2-3 seconds per page

#### Supported Website Types

✅ **E-commerce**: Amazon, Shopify, WooCommerce, Magento\
✅ **News & Media**: WordPress, Medium, Substack, news sites\
✅ **Documentation**: GitBook, Notion, Confluence, wikis\
✅ **Social Platforms**: LinkedIn, Twitter, Reddit (public data)\
✅ **Business Sites**: Company websites, landing pages, directories\
✅ **Academic**: Research portals, university sites, journals\
✅ **Government**: Official websites, public records, databases

#### AI-Optimized Features

- **Content Cleaning**: Removes ads, navigation, and irrelevant elements
- **Structure Detection**: Identifies articles, products, reviews automatically
- **Metadata Extraction**: Pulls dates, authors, categories, tags
- **Language Processing**: Detects language and encoding automatically
- **Duplicate Removal**: Eliminates redundant content across pages

### 💡 Best Practices for AI Applications

#### LLM Training Data

1. **Use bulk processing** for large datasets
2. **Enable content cleaning** for higher quality text
3. **Extract metadata** for better data organization
4. **Set appropriate delays** to respect website resources

#### RAG System Integration

1. **Structure content** into chunks for better retrieval
2. **Maintain source attribution** for transparency
3. **Extract relevant metadata** for filtering
4. **Use consistent formatting** across documents

#### Competitive Intelligence

1. **Schedule regular runs** for continuous monitoring
2. **Track specific data points** like prices, features
3. **Set up alerts** for significant changes
4. **Maintain historical data** for trend analysis

### 🔒 Compliance & Ethics

#### Legal Compliance

- Respects robots.txt and website terms of service
- Implements rate limiting to prevent server overload
- Provides clear user-agent identification
- Supports GDPR and privacy regulations

#### Ethical AI Usage

- Only scrapes publicly available information
- Avoids personal or sensitive data collection
- Implements proper data handling practices
- Supports responsible AI development

### 🦾 Related AI Tools on Apify

Explore other powerful AI-focused scrapers on the Apify platform:

🌐 **[Website Content Crawler](https://apify.com/apify/website-content-crawler)** - Specialized content extraction\
🍒 **[Cheerio Scraper](https://apify.com/apify/cheerio-scraper)** - High-performance HTML parsing\
🔍 **[Google Search Scraper](https://apify.com/datascoutapi/google-search-results-scraper)** - SERP data for AI training

### ❓ Frequently Asked Questions

#### How to extract website data for AI training?

1. **Select target websites** with high-quality content
2. **Configure AI-optimized extraction** settings
3. **Use bulk processing** for large datasets
4. **Export in AI-friendly formats** (JSON, structured text)
5. **Integrate with your ML pipeline** using our API

#### Can I use Web Scraper with ChatGPT and other LLMs?

Yes! Web Scraper is specifically designed for AI applications. The extracted content is pre-processed and cleaned for optimal use with ChatGPT, Claude, Llama, and other language models.

#### How does Web Scraper handle Cloudflare protection?

Web Scraper includes advanced anti-detection technology that automatically handles Cloudflare challenges, JavaScript rendering, and bot detection systems without additional configuration.

#### Can I integrate with vector databases like Pinecone or Weaviate?

Absolutely! Web Scraper outputs structured data that's ready for vector database ingestion. We provide examples for popular vector databases and embedding services.

#### Is it legal to scrape data for AI training?

Scraping publicly available, non-personal data is generally legal. However, always respect website terms of service and applicable regulations like GDPR. For personal data or sensitive information, consult legal experts.

#### How much does it cost to scrape data for AI projects?

With Apify's free plan ($5 monthly credits), you can scrape thousands of pages. For larger AI projects, our paid plans offer better value with bulk pricing. Check our [pricing page](https://apify.com/pricing) for details.

### 🆘 Support & API Integration

#### Getting Help

- 📚 **[Complete Documentation](https://docs.apify.com/actors/web-scraper-pro)**
- 💬 **[Community Forum](https://community.apify.com)** - Get help from other AI developers
- 📧 **[Direct Support](mailto:support@apify.com)** - Technical assistance
- 🎥 **[Video Tutorials](https://youtube.com/apify)** - Step-by-step guides

#### API Integration Examples

**Node.js:**

```javascript
const { ApifyApi } = require('apify-client');
const client = new ApifyApi({ token: 'your-token' });

const run = await client.actor('web-scraper-pro').call({
  startUrls: [{ url: 'https://example.com' }]
});

const scrapedData = await client.dataset(run.defaultDatasetId).listItems();
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('your-token')

run = client.actor('web-scraper-pro').call(
    run_input={
        'startUrls': [{'url': 'https://example.com'}]
    }
)

scraped_data = client.dataset(run['defaultDatasetId']).list_items()
```

***

**Ready to power your AI projects with high-quality web data?** 🚀

Transform any website into structured, AI-ready datasets with Web Scraper - the most advanced web scraping solution for modern AI applications.

### Your Feedback

We're constantly improving Web Scraper based on user feedback. If you have suggestions, found a bug, or need help with your AI scraping project, please create an issue in the **Issues** tab. Our team responds quickly to help you succeed with your data extraction needs.

### 📬 Contact & Support

Have questions, need help, or interested in a private or custom instance?

Reach our team anytime at datascoutapi@gmail.com

# Actor input Schema

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

Add 1-10 URLs to crawl. Single URL ($0.008) or Multiple URLs ($0.04 for 2-10 URLs). Maximum 10 URLs per request.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

Complete scraped data with all fields

# 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 = {
    "startUrls": [
        {
            "url": "https://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutapi/web-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 = { "startUrls": [{ "url": "https://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutapi/web-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 '{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}' |
apify call datascoutapi/web-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Web Scraper 🚀",
        "description": "Web Scraper Pro extracts clean structured data for LLMs/RAG. Browser-based, 10x faster with anti-detection bypassing Cloudflare/CAPTCHA & proxy rotation. Bulk/recursive crawl 50k URLs at 500 pages/min. JSON/CSV/API, free tier.",
        "version": "0.1",
        "x-build-id": "ggPjbh86H4TaYIHaA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutapi~web-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutapi-web-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/datascoutapi~web-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascoutapi-web-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/datascoutapi~web-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutapi-web-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Add 1-10 URLs to crawl. Single URL ($0.008) or Multiple URLs ($0.04 for 2-10 URLs). Maximum 10 URLs per request.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Website URL to crawl (e.g., https://example.com)",
                                    "pattern": "^https?://.+"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```