# Instagram Highlights Scraper (`scrapapi/instagram-highlights-scraper`) Actor

Extract Instagram Highlights data from public profiles with this scraper. Collect highlight titles, story media URLs, timestamps, captions, and profile details. Useful for brand research, influencer analysis, content monitoring, and tracking stories saved in Instagram Highlights.

- **URL**: https://apify.com/scrapapi/instagram-highlights-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/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

### Instagram Highlights Scraper

Instagram Highlights Scraper is a production-ready Apify actor that extracts structured Instagram Highlight metadata from public profiles — including highlight titles, IDs, cover images, and profile identifiers — so you can scrape Instagram highlights at scale without manual work. It solves the pain of copy-paste and screen recording by streaming clean results into a dataset in real time, making it ideal for marketers, developers, data analysts, and researchers. Use this Instagram highlights extractor to power brand research, competitor monitoring, and content archiving workflows with reliable automation.

### What data / output can you get?

Below are the exact fields this actor streams to the Apify dataset for each highlight. Results are exportable as JSON or CSV for easy downstream use.

| Data field | Description | Example value |
| --- | --- | --- |
| input_url | Resolved Instagram profile URL used for the scrape | https://www.instagram.com/mrbeast/ |
| username | Profile username extracted from input | mrbeast |
| user_id | Numeric Instagram user ID resolved via GraphQL | 1234567890 |
| type | Constant type tag for all items | instagram_highlights |
| id | Unique highlight identifier | highlight:18069978917514346 |
| title | Highlight title as shown on the profile | Travels ✈️ |
| cover_media | URL of the highlight cover image (if available) | https://scontent.cdninstagram.com/.../cover.jpg |
| success | Whether the item was scraped successfully | true |
| error | Error message if scrape failed for this item | null |
| timestamp | UTC ISO timestamp when the item was created | 2026-04-16T10:25:43.123Z |

Notes:
- Outputs are pushed item-by-item during the run for real-time streaming and monitoring.
- Exports are available in JSON and CSV from the Apify dataset.

### Key features

- ⚡ Real-time streaming output
  Pushes each highlight to the dataset immediately using Actor.push_data, enabling live monitoring and faster pipelines.

- 🛡️ Smart proxy fallback & resilience
  Automatic policy with fail-fast detection: start with no proxy, fallback to Apify datacenter, then to residential with up to 3 attempts. Once residential is used, the run stays “sticky” on residential for stability.

- 🌍 No login required (public profiles)
  Works against publicly available Instagram profiles without authentication or cookies.

- 📥 Flexible inputs with robust validation
  Accepts full profile URLs (https://www.instagram.com/username) and usernames (with or without @). Pure highlight shortcodes are validated and will return a clear error item if additional API calls would be required.

- 📊 Clean JSON/CSV dataset
  Produces structured, ready-to-export results with consistent field names for downstream analytics and automation.

- 🧰 Built on Apify infrastructure
  Production-ready actor with retries, backoff, and platform-grade logging to keep scrapes running even when Instagram rate-limits or blocks.

### How to use Instagram Highlights Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Instagram Highlights Scraper actor on the Apify platform.
3. Prepare your input:
   - Add startUrls as a list of profile URLs or usernames (e.g., https://www.instagram.com/username or @username).
   - The actor also handles legacy items shaped as objects with a url key internally, but the recommended format is a string list.
4. Configure proxyConfiguration (optional):
   - If you enable Apify Proxy, the actor will respect your setting and still fallback automatically on block detection.
5. Start the run:
   - The actor loads each profile, resolves tokens, fetches the user_id, then queries the Instagram GraphQL endpoint for highlights.
6. Monitor progress:
   - Items are pushed to the dataset in real time. Logs will show the proxy strategy and data pushes per highlight.
7. Download results:
   - Export your dataset to JSON or CSV directly from the run’s dataset tab.

Pro Tip: If you expect 429/403 responses, enable Apify Residential proxies from the start for maximum stability on high-volume runs.

### Use cases

| Use case | Description |
| --- | --- |
| Brand research & competitor tracking | Aggregate highlight titles and cover art across competitors to analyze content themes at scale. |
| Influencer analysis | Enumerate highlight collections for influencer profiles to understand evergreen content pillars and campaigns. |
| Content monitoring & QA | Track highlight additions and changes over time by rerunning profiles and comparing cover images and titles. |
| Campaign archiving | Export Instagram highlights as structured records to back up evergreen story sets for compliance or reporting. |
| Bulk profile audits | Run large lists of usernames to build a highlight inventory for market scans and editorial planning. |
| Data enrichment pipeline | Feed structured highlight metadata (id, title, cover_media, user_id) into internal dashboards or analytics models. |

### Why choose Instagram Highlights Scraper?

Built for precision, resilience, and scale, this actor focuses on clean highlight metadata extraction with production-ready reliability.

- ✅ Accurate, structured fields: Consistent keys for easy parsing (input_url, username, user_id, id, title, cover_media, success, error, timestamp).
- 🚀 Scalable batch runs: Processes many profiles via startUrls with auto retries and backoff.
- 🛡️ Robust blocking strategy: Automatic no-proxy → datacenter → residential fallback with sticky residential mode.
- 💾 JSON/CSV exports: Download clean datasets without manual cleanup.
- 🔧 Developer-friendly on Apify: Streamed outputs and clear logs simplify automation and debugging.
- 🔒 Public-data only: Works against publicly available profiles — no login or private data access.

In short: a stable, automation-first Instagram highlights saver tool for teams that need repeatable, reliable results.

### Is it legal / ethical to use Instagram Highlights Scraper?

Yes — when done responsibly. This actor accesses publicly available Instagram profile pages and extracts highlight metadata from them. It does not access private profiles or require login.

Guidelines for compliant use:
- Only use data from public profiles and for legitimate purposes.
- Respect Instagram’s Terms of Service and your local regulations (e.g., GDPR/CCPA).
- Do not use scraped data for spam or abusive activity.
- Consult your legal team for edge cases or redistribution policies.

### Input parameters & output format

Example input (recommended string list editor):
```json
{
  "startUrls": [
    "https://www.instagram.com/mrbeast/",
    "@nasa",
    "instagram"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Parameter reference:

- startUrls
  - Type: array
  - Description: Add one or more targets — each line is one input. Accepted: full profile URL (https://www.instagram.com/username), username (username or @username), or highlight shortcode (ABC123DEF45). The actor resolves each to the profile and scrapes all highlights (title, ID, cover image, success/error, timestamp). Perfect for bulk extraction across many accounts.
  - Default: none
  - Required: yes

- proxyConfiguration
  - Type: object
  - Description: Choose which proxies to use. Strategy: start with your selection (e.g. no proxy or Apify proxy). On HTTP 429 or 403 (platform block), the actor fails fast and falls back: first to datacenter, then to residential. Residential gets up to 3 retries with a new proxy URL each time; once residential is used, it stays in “sticky” mode for all remaining URLs so the run stays stable.
  - Default: {"useApifyProxy": true}
  - Required: no

Example output item (success):

```json
{
  "input_url": "https://www.instagram.com/mrbeast/",
  "username": "mrbeast",
  "user_id": "1234567890",
  "type": "instagram_highlights",
  "id": "highlight:18069978917514346",
  "title": "Travels ✈️",
  "cover_media": "https://scontent.cdninstagram.com/path/to/cover.jpg",
  "success": true,
  "error": null,
  "timestamp": "2026-04-16T10:25:43.123Z"
}
```

Example output item (validation error case):

```json
{
  "input_url": "ABC123DEF45",
  "username": null,
  "user_id": null,
  "type": "instagram_highlights",
  "id": null,
  "title": null,
  "cover_media": null,
  "success": false,
  "error": "Shortcode detected but username extraction from shortcode requires additional API calls",
  "timestamp": "2026-04-16T10:25:43.456Z"
}
```

Notes:

- Fields that may be null (Unknown) include cover\_media (if no cover was found) and error (when success is true).
- The actor also gracefully logs and emits error items when inputs are invalid or requests are blocked beyond retries.

### FAQ

#### Can I use this as an Instagram highlights downloader?

Yes — for metadata and cover images. The actor extracts highlight IDs, titles, and cover\_media URLs from public profiles. It does not fetch individual story media inside highlights.

#### Does it work without login?

Yes. The scraper targets publicly available profile pages and does not require authentication to extract highlight metadata.

#### What happens if I input a highlight shortcode?

The input schema mentions shortcodes, but the current implementation treats pure shortcodes as requiring additional API calls. In such cases, the actor will push a clear error item indicating that the shortcode cannot be resolved without further steps.

#### What output fields are included?

Each item contains: input\_url, username, user\_id, type, id, title, cover\_media, success, error, and timestamp. These are streamed to the dataset as JSON and can be exported to CSV.

#### How does the proxy fallback strategy work?

The run starts with no proxy by default. On 429/403 block detection, it fails fast and retries with an Apify datacenter proxy. If blocks persist, it switches to Residential proxies with up to 3 attempts and then sticks to residential for all remaining URLs.

#### Can I download Instagram highlight covers?

Yes. The cover\_media field contains the image URL for the highlight cover (when available), which you can save downstream as part of your Instagram highlights archiver workflow.

#### How many profiles can I process in one run?

As many as you include in startUrls, subject to your Apify plan limits and runtime settings. The actor processes inputs sequentially with automatic retries and backoff.

#### What errors will be recorded in the dataset?

When an input is invalid (e.g., non-Instagram URL or unsupported shortcode) or a proxy path exhausts its retries, the actor pushes an item with success=false and a descriptive error message for traceability.

### Closing CTA / Final thoughts

Instagram Highlights Scraper is built to extract clean, structured highlight metadata from public Instagram profiles at scale. With real-time dataset streaming, smart proxy fallback, and JSON/CSV exports, it helps marketers, analysts, researchers, and developers export Instagram highlights reliably for analysis and archiving. Developers can plug the dataset into automation on the Apify platform, or download results for pipelines and dashboards. Start extracting smarter highlight insights today — and scale your Instagram research with resilient, production-grade scraping.

# Actor input Schema

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

🔗 Add one or more targets — each line is one input. Accepted: full profile URL (https://www.instagram.com/username), username (username or @username), or highlight shortcode (ABC123DEF45). The actor resolves each to the profile and scrapes all highlights (title, ID, cover image, success/error, timestamp). Perfect for bulk extraction across many accounts.

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

Choose which proxies to use. Strategy: start with your selection (e.g. no proxy or Apify proxy). On HTTP 429 or 403 (platform block), the actor fails fast and falls back: first to datacenter, then to residential. Residential gets up to 3 retries with a new proxy URL each time; once residential is used, it stays in "sticky" mode for all remaining URLs so the run stays stable.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.instagram.com/mrbeast/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "https://www.instagram.com/mrbeast/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/instagram-highlights-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": ["https://www.instagram.com/mrbeast/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/instagram-highlights-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": [
    "https://www.instagram.com/mrbeast/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapapi/instagram-highlights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Highlights Scraper",
        "description": "Extract Instagram Highlights data from public profiles with this scraper. Collect highlight titles, story media URLs, timestamps, captions, and profile details. Useful for brand research, influencer analysis, content monitoring, and tracking stories saved in Instagram Highlights.",
        "version": "0.1",
        "x-build-id": "lsNwY7bzI6VLrVWmS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~instagram-highlights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-instagram-highlights-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/scrapapi~instagram-highlights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-instagram-highlights-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/scrapapi~instagram-highlights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-instagram-highlights-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": "📥 Instagram Profile URLs, Usernames, or Shortcodes",
                        "type": "array",
                        "description": "🔗 Add one or more targets — each line is one input. Accepted: full profile URL (https://www.instagram.com/username), username (username or @username), or highlight shortcode (ABC123DEF45). The actor resolves each to the profile and scrapes all highlights (title, ID, cover image, success/error, timestamp). Perfect for bulk extraction across many accounts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. Strategy: start with your selection (e.g. no proxy or Apify proxy). On HTTP 429 or 403 (platform block), the actor fails fast and falls back: first to datacenter, then to residential. Residential gets up to 3 retries with a new proxy URL each time; once residential is used, it stays in \"sticky\" mode for all remaining URLs so the run stays stable."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
