# RedGifs Downloader: Bulk HD Video Scraper & API (`vnx0/redgifs`) Actor

The ultimate RedGifs Downloader. Bulk download videos from users, search results, or categories in HD. Scrape metadata, filter content, and export to JSON.

- **URL**: https://apify.com/vnx0/redgifs.md
- **Developed by:** [Vnx0](https://apify.com/vnx0) (community)
- **Categories:** Social media, Other, Videos
- **Stats:** 198 total users, 7 monthly users, 99.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## RedGIFs Content Scraper

A professional Apify Actor for scraping content, creators, and metadata from RedGIFs.com. Perfect for research, content analysis, and data collection.

### 🚀 Features

- **Content Extraction**: Scrape GIFs, videos, and images with metadata
- **Creator Profiles**: Extract creator information and follower counts
- **Trending Data**: Capture trending tags, creators, and niches
- **Niche Categories**: Discover specialized content categories
- **Rich Metadata**: View counts, durations, thumbnails, and more
- **Multiple Formats**: Export data as JSON or CSV
- **Rate Limiting**: Respectful scraping with configurable delays
- **Proxy Support**: Built-in Apify proxy integration
- **Error Handling**: Robust error handling and retry mechanisms

### 📊 Use Cases

- **Content Research**: Analyze trending content and creator performance
- **Market Analysis**: Study adult content market trends and preferences
- **Academic Research**: Gather data for social media and content studies
- **Content Curation**: Discover popular creators and trending categories
- **Data Analytics**: Build datasets for machine learning and analysis

### 🔧 Configuration

#### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | Array | `["amateur"]` | Categories to scrape (e.g., amateur, teen, milf) |
| `maxItemsPerCategory` | Integer | `100` | Maximum items to scrape per category (1-1000) |
| `includeCreators` | Boolean | `true` | Whether to scrape creator profiles |
| `includeNiches` | Boolean | `true` | Whether to scrape niche categories |
| `includeTrendingData` | Boolean | `true` | Whether to scrape trending data from main page |
| `outputFormat` | String | `"json"` | Output format: "json" or "csv" |
| `delayBetweenRequests` | Number | `2` | Delay between requests in seconds (1-10) |
| `maxConcurrency` | Integer | `1` | Maximum concurrent browser instances (1-5) |
| `debugMode` | Boolean | `false` | Enable debug logging and screenshots |
| `proxyConfiguration` | Object | Apify Proxy | Proxy settings for the scraper |

#### Example Input

```json
{
  "categories": ["amateur", "teen", "milf"],
  "maxItemsPerCategory": 200,
  "includeCreators": true,
  "includeNiches": true,
  "includeTrendingData": true,
  "outputFormat": "json",
  "delayBetweenRequests": 3,
  "debugMode": false
}
````

### 📈 Output Data

The Actor outputs structured data to the dataset with the following types:

#### Content Items

```json
{
  "type": "content_item",
  "id": "limegreenbleakleafhopper",
  "category": "amateur",
  "title": null,
  "url": "/watch/limegreenbleakleafhopper",
  "thumbnail": "https://media.redgifs.com/...",
  "duration": "0:18",
  "view_count": "43K",
  "creator": "hotredwildcat",
  "media_urls": {
    "poster": "https://media.redgifs.com/LimegreenBleakLeafhopper-poster.jpg",
    "mobile": "https://media.redgifs.com/LimegreenBleakLeafhopper-mobile.jpg",
    "medium": "https://media.redgifs.com/LimegreenBleakLeafhopper-medium.jpg"
  },
  "scraped_at": "2024-01-15T10:30:00Z"
}
```

#### Creator Profiles

```json
{
  "type": "creator",
  "username": "hotredwildcat",
  "display_name": "Hot Red Wildcat",
  "profile_image": "https://userpic.redgifs.com/...",
  "follower_count": "35K",
  "category": "amateur",
  "scraped_at": "2024-01-15T10:30:00Z"
}
```

#### Trending Tags

```json
{
  "type": "trending_tag",
  "name": "cumslut",
  "display_text": "cumslut 48K",
  "url": "/gifs/cumslut",
  "view_count": "48K",
  "scraped_at": "2024-01-15T10:30:00Z"
}
```

#### Niche Categories

```json
{
  "type": "niche",
  "name": "age-gap",
  "display_name": "Age Gap",
  "thumbnail": "https://userpic.redgifs.com/niches/thumbnails/age-gap.jpg",
  "subscriber_count": "47K",
  "related_category": "amateur",
  "scraped_at": "2024-01-15T10:30:00Z"
}
```

### 🏃‍♂️ Running the Actor

#### On Apify Platform

1. **Find the Actor**: Search for "RedGIFs Content Scraper" in Apify Store
2. **Configure Input**: Set your desired categories and parameters
3. **Run**: Click "Start" to begin scraping
4. **Download Results**: Export data as JSON, CSV, or Excel

#### Locally with Apify CLI

```bash
## Install Apify CLI
npm install -g apify-cli

## Clone the Actor
apify create my-redgifs-scraper --template redgifs-scraper

## Install dependencies
cd my-redgifs-scraper
pip install -r requirements.txt

## Run locally
apify run

## Run with custom input
echo '{"categories": ["amateur"], "maxItemsPerCategory": 50}' | apify run --input-file=-
```

### 📊 Performance & Limits

- **Speed**: ~50-100 items per minute (depending on configuration)
- **Concurrency**: 1-5 concurrent browser instances
- **Rate Limiting**: 1-10 seconds delay between requests
- **Memory Usage**: ~500MB-2GB (depending on concurrency)
- **Proxy Support**: Apify residential and datacenter proxies

### 🛡️ Compliance & Ethics

- **Rate Limiting**: Respectful scraping with configurable delays
- **Robots.txt**: Follows website's robots.txt guidelines
- **Terms of Service**: Users responsible for compliance with RedGIFs ToS
- **Data Usage**: Intended for research, analysis, and legitimate use cases
- **Age Verification**: Content is from an adult platform (18+ only)

### 🔍 Troubleshooting

#### Common Issues

1. **No Data Returned**
   - Check if categories exist on RedGIFs
   - Verify proxy configuration
   - Enable debug mode for detailed logs

2. **Rate Limiting Errors**
   - Increase `delayBetweenRequests` parameter
   - Reduce `maxConcurrency` to 1
   - Use residential proxies

3. **Browser Timeout**
   - Reduce `maxItemsPerCategory`
   - Check proxy connectivity
   - Enable debug mode for screenshots

#### Debug Mode

Enable `debugMode: true` to get:

- Detailed logging
- Error screenshots
- Browser console logs
- Network request information

### 📝 Changelog

#### Version 1.0.0

- Initial release
- Content item extraction
- Creator profile scraping
- Trending data collection
- Niche category discovery
- JSON/CSV export support
- Proxy integration
- Error handling and retry logic

### 🤝 Support

- **Documentation**: [Apify Docs](https://docs.apify.com)
- **Community**: [Apify Discord](https://discord.com/invite/jyEM2PRvMU)
- **Issues**: Report bugs via Actor feedback
- **Custom Development**: Contact for custom scraping solutions

### ⚖️ Legal Notice

This Actor is designed for legitimate research, analysis, and data collection purposes. Users are responsible for:

- Complying with RedGIFs Terms of Service
- Respecting website rate limits and robots.txt
- Using scraped data ethically and legally
- Ensuring compliance with local laws and regulations
- Verifying age restrictions (18+ content)

The Actor developers are not responsible for misuse of this tool or violation of any terms of service.

### 🏷️ Tags

`web-scraping` `adult-content` `data-extraction` `content-analysis` `research` `redgifs` `playwright` `python`

# Actor input Schema

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

List of RedGIFs categories to scrape (e.g., amateur, teen, milf, etc.)

## `maxItemsPerCategory` (type: `integer`):

Maximum number of content items to scrape per category

## `includeCreators` (type: `boolean`):

Whether to scrape creator profile information

## `includeNiches` (type: `boolean`):

Whether to scrape related niche categories

## `includeTrendingData` (type: `boolean`):

Whether to scrape trending tags and content from main page

## `userProfilesToScrape` (type: `array`):

List of specific user profiles to scrape (e.g., \['username1', 'username2'])

## `nichesToScrape` (type: `array`):

List of specific niches to scrape (e.g., \['niche1', 'niche2'])

## `bulkUrls` (type: `array`):

List of RedGIFs URLs to scrape (users, niches, categories, or content). Supports mixed URL types.

## `outputFormat` (type: `string`):

Format for exported data

## `delayBetweenRequests` (type: `integer`):

Delay between HTTP requests to avoid rate limiting (in seconds)

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent requests

## `debugMode` (type: `boolean`):

Enable debug logging and additional output

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

Proxy settings for the scraper

## Actor input object example

```json
{
  "categories": [
    "amateur",
    "teen",
    "milf"
  ],
  "maxItemsPerCategory": 100,
  "includeCreators": true,
  "includeNiches": true,
  "includeTrendingData": true,
  "userProfilesToScrape": [],
  "nichesToScrape": [],
  "bulkUrls": [],
  "outputFormat": "json",
  "delayBetweenRequests": 2,
  "maxConcurrency": 1,
  "debugMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "categories": [
        "amateur",
        "teen",
        "milf"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vnx0/redgifs").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "categories": [
        "amateur",
        "teen",
        "milf",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("vnx0/redgifs").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "categories": [
    "amateur",
    "teen",
    "milf"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call vnx0/redgifs --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedGifs Downloader: Bulk HD Video Scraper & API",
        "description": "The ultimate RedGifs Downloader. Bulk download videos from users, search results, or categories in HD. Scrape metadata, filter content, and export to JSON.",
        "version": "0.0",
        "x-build-id": "chz18YgzfnPBdQIht"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vnx0~redgifs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vnx0-redgifs",
                "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/vnx0~redgifs/runs": {
            "post": {
                "operationId": "runs-sync-vnx0-redgifs",
                "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/vnx0~redgifs/run-sync": {
            "post": {
                "operationId": "run-sync-vnx0-redgifs",
                "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": [
                    "categories"
                ],
                "properties": {
                    "categories": {
                        "title": "Categories to scrape",
                        "type": "array",
                        "description": "List of RedGIFs categories to scrape (e.g., amateur, teen, milf, etc.)",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "amateur"
                        ]
                    },
                    "maxItemsPerCategory": {
                        "title": "Maximum items per category",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of content items to scrape per category",
                        "default": 100
                    },
                    "includeCreators": {
                        "title": "Include creator profiles",
                        "type": "boolean",
                        "description": "Whether to scrape creator profile information",
                        "default": true
                    },
                    "includeNiches": {
                        "title": "Include niche categories",
                        "type": "boolean",
                        "description": "Whether to scrape related niche categories",
                        "default": true
                    },
                    "includeTrendingData": {
                        "title": "Include trending data",
                        "type": "boolean",
                        "description": "Whether to scrape trending tags and content from main page",
                        "default": true
                    },
                    "userProfilesToScrape": {
                        "title": "User Profiles to Scrape",
                        "type": "array",
                        "description": "List of specific user profiles to scrape (e.g., ['username1', 'username2'])",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "nichesToScrape": {
                        "title": "Niches to Scrape",
                        "type": "array",
                        "description": "List of specific niches to scrape (e.g., ['niche1', 'niche2'])",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "bulkUrls": {
                        "title": "Bulk URLs to Scrape",
                        "type": "array",
                        "description": "List of RedGIFs URLs to scrape (users, niches, categories, or content). Supports mixed URL types.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "json",
                            "csv"
                        ],
                        "type": "string",
                        "description": "Format for exported data",
                        "default": "json"
                    },
                    "delayBetweenRequests": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Delay between HTTP requests to avoid rate limiting (in seconds)",
                        "default": 2
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of concurrent requests",
                        "default": 1
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable debug logging and additional output",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
