# Instagram Reels Audio Scraper (`automation-lab/instagram-reels-audio-scraper`) Actor

🎵 Extract public Instagram Reels audio metadata, artists, usage signals, and representative Reels without login.

- **URL**: https://apify.com/automation-lab/instagram-reels-audio-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.31 / 1,000 audio records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reels Audio Scraper

Extract public Instagram Reels audio metadata and representative Reels without logging in.

Use audio page URLs or numeric audio IDs to build monitoring-ready datasets for sound research, creator campaigns, and trend analysis.

- 🎵 Normalize audio IDs and canonical music IDs
- 📊 Capture public usage signals and representative Reel engagement
- 👤 Identify artists and creators when Instagram exposes them
- 🔁 Deduplicate repeated URLs and IDs automatically
- 🕒 Add stable scrape timestamps for recurring comparisons

### What does Instagram Reels Audio Scraper do?

Instagram Reels Audio Scraper visits public Instagram audio pages and returns one normalized record per audio source.

Each record can include:

- audio ID
- canonical audio ID
- audio title
- artist or creator
- original-versus-licensed classification
- public audio media URL
- duration
- thumbnail
- public usage count
- bounded sample of associated Reels
- scrape timestamp

Unavailable fields are omitted rather than filled with misleading values.

### Who is it for?

#### Social media agencies

Monitor sounds used across client campaigns and compare representative posts over time.

#### Creators

Research how a sound is reused before planning a new Reel.

#### Music marketers

Collect public examples of creator adoption and engagement around tracks.

#### Influencer teams

Find representative creators using an audio asset and export results for outreach research.

#### Trend researchers

Take recurring snapshots of public audio pages for downstream change detection.

### Why use this Instagram audio scraper?

Manual audio-page research does not scale well.

Audio IDs, creator details, engagement signals, and media links are spread across Instagram responses.

This Actor converts those responses into stable JSON records that can be exported, scheduled, and integrated.

It does not require Instagram credentials and only targets public pages.

### Input

Provide `audioInputs` containing public Instagram audio URLs or numeric IDs.

```json
{
  "audioInputs": [
    "579408562507956",
    "https://www.instagram.com/reels/audio/579408562507956/"
  ],
  "maxItems": 10,
  "maxReelsPerAudio": 20
}
````

| Field | Type | Description |
|---|---|---|
| `audioInputs` | string\[] | Public audio URLs or numeric audio IDs |
| `maxItems` | integer | Maximum unique audio records |
| `maxReelsPerAudio` | integer | Maximum Reel samples embedded per audio |
| `proxyConfiguration` | object | Optional Apify Proxy settings |

Duplicate representations of the same audio ID produce one record.

### Output data

The default dataset contains one item per audio ID.

| Field | Type | Description |
|---|---|---|
| `audioId` | string | ID requested by the user |
| `canonicalAudioId` | string | Canonical music ID when exposed |
| `title` | string | Audio or track title |
| `artist` | string | Display artist or original creator |
| `artistUsername` | string | Instagram username when exposed |
| `isOriginalAudio` | boolean | Whether Instagram classifies it as original audio |
| `audioType` | string | Instagram audio classification |
| `audioUrl` | string | Temporary public audio media URL when exposed |
| `durationSeconds` | number | Duration visible in the public response |
| `thumbnailUrl` | string | Representative public thumbnail |
| `usageCount` | number | Public Reel usage count when exposed |
| `sourceUrl` | string | Canonical audio page |
| `reels` | object\[] | Bounded representative Reel samples |
| `reelsReturned` | integer | Number of embedded Reel samples |
| `scrapedAt` | string | UTC extraction timestamp |

### Reel sample fields

Each object in `reels` can contain:

- Reel ID and shortcode
- public Reel URL
- caption
- creator username and display name
- creator ID
- like and comment counts
- play and view counts
- video duration
- thumbnail and temporary video URL
- publication timestamp

Instagram may omit metrics or media links for some public posts.

### Example output

```json
{
  "audioId": "579408562507956",
  "title": "Original audio",
  "artist": "Public creator",
  "isOriginalAudio": true,
  "audioType": "original_sounds",
  "sourceUrl": "https://www.instagram.com/reels/audio/579408562507956/",
  "reelsReturned": 5,
  "reels": [
    {
      "shortcode": "EXAMPLE",
      "url": "https://www.instagram.com/reel/EXAMPLE/",
      "creatorUsername": "creator",
      "likeCount": 120
    }
  ],
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
```

### How to scrape Instagram Reels audio

1. Open a public Reel in Instagram.
2. Follow the linked audio name to its public audio page.
3. Copy the `/reels/audio/<id>/` URL.
4. Add it to `audioInputs`.
5. Choose a small Reel sample limit.
6. Start the Actor.
7. Export the dataset as JSON, CSV, Excel, or another supported format.

### How much does it cost to scrape Instagram Reels audio?

The Actor uses pay-per-event pricing.

A small one-time start event covers run initialization, followed by a charge per audio record produced.

You are not charged per embedded Reel sample.

Exact tier prices are displayed on the Actor page before a run starts.

Keep first tests small, then increase `maxItems` after validating the output.

### Monitoring workflow

Run the Actor on a schedule with the same audio IDs.

Use `scrapedAt`, `usageCount`, and Reel engagement fields to compare snapshots.

For long-term analysis, store each run in a named dataset or send records to your warehouse.

Avoid treating a single snapshot as a complete historical trend.

### Tips for reliable results

- Use only public audio pages.
- Start with a few audio IDs.
- Keep `maxReelsPerAudio` bounded.
- Enable Apify Proxy if direct traffic is rate-limited.
- Retry later when Instagram temporarily limits a page.
- Store media files promptly because CDN URLs can expire.
- Schedule moderate recurring runs rather than aggressive bursts.

### Integrations

Connect results to:

- Google Sheets for campaign reviews
- Airtable for creator research
- Slack for monitoring alerts
- Make for no-code routing
- Zapier for workflow triggers
- webhooks for internal services
- cloud storage for snapshots
- data warehouses for trend analysis

A common workflow compares the latest usage count with the previous scheduled run and alerts only when growth crosses a threshold.

### API usage

#### JavaScript example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/instagram-reels-audio-scraper').call({
  audioInputs: ['579408562507956'],
  maxItems: 1,
  maxReelsPerAudio: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/instagram-reels-audio-scraper').call(run_input={
    'audioInputs': ['579408562507956'],
    'maxItems': 1,
    'maxReelsPerAudio': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~instagram-reels-audio-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"audioInputs":["579408562507956"],"maxItems":1,"maxReelsPerAudio":10}'
```

### Use with MCP and AI agents

Connect through the Apify MCP server:

`https://mcp.apify.com/?tools=automation-lab/instagram-reels-audio-scraper`

Example prompts:

- “Scrape this Instagram audio ID and summarize representative creators.”
- “Compare public engagement in the Reel sample for these audio pages.”
- “Save a monitoring snapshot for these Instagram sounds.”

For Claude Code, register the Actor as an HTTP MCP server:

```bash
claude mcp add --transport http instagram-reels-audio 'https://mcp.apify.com/?tools=automation-lab/instagram-reels-audio-scraper'
```

For Claude Desktop, Cursor, or VS Code, add this server to the application's MCP JSON configuration:

```json
{
  "mcpServers": {
    "instagram-reels-audio": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/instagram-reels-audio-scraper"
    }
  }
}
```

Restart the client after saving the configuration, then use one of the actor-specific prompts above.

### Errors and troubleshooting

#### Why did an audio page return no record?

The ID may be invalid, removed, private, geographically unavailable, or temporarily rate-limited.

Confirm the page opens publicly and retry with Apify Proxy enabled.

#### Why are some fields missing?

Instagram does not expose every licensing field or metric for every audio object.

The Actor preserves valid partial records and omits absent optional fields.

#### Why is a media URL no longer available?

Instagram CDN links are temporary.

Download permitted media promptly if your workflow requires a durable copy.

### Limits

The Actor does not:

- log in to Instagram
- access private content
- guarantee every Reel using an audio
- bypass geographic or rights restrictions
- provide historical metrics before your first snapshot
- guarantee permanent CDN links

The Reel sample is representative and bounded, not an exhaustive usage archive.

### Is it legal to scrape public Instagram data?

Scraping legality depends on jurisdiction, purpose, and how data is used.

Only collect public information you are permitted to process.

Respect privacy, intellectual-property rights, platform terms, and applicable laws.

Do not use the Actor to access private accounts or evade access controls.

### FAQ

#### Does it require an Instagram account?

No. The supported scope uses public audio pages without login.

#### Can I submit the same ID twice?

Yes. Duplicate IDs and equivalent audio URLs are deduplicated.

#### Are licensed songs supported?

When Instagram exposes public music metadata, the Actor returns it. Availability varies by audio and region.

#### Can I get every Reel using a sound?

No. The Actor returns a bounded representative sample exposed by the public audio page.

#### Can I schedule monitoring?

Yes. Use Apify schedules and compare records by `audioId` and `scrapedAt`.

#### Does the Actor download audio files?

It returns a temporary public media URL when Instagram exposes one. It does not persist files automatically.

### Related Instagram scrapers

Explore other actors from [automation-lab](https://apify.com/automation-lab) for Instagram profiles, comments, hashtags, stories, and follower metrics.

Use this Actor when the primary entity is an audio object and its representative public Reels.

### Support

If a valid public audio page repeatedly fails, open an issue from the Actor page.

Include the public URL, input limits, run ID, and whether proxying was enabled.

Do not include private credentials or personal account cookies.

# Actor input Schema

## `audioInputs` (type: `array`):

Public Instagram /reels/audio/ URLs or numeric audio IDs. Duplicates are removed.

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

Maximum number of unique audio pages to return.

## `maxReelsPerAudio` (type: `integer`):

Maximum representative public Reels embedded in each audio record.

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

Optional Apify Proxy settings. Residential proxies can improve reliability when Instagram limits datacenter traffic.

## Actor input object example

```json
{
  "audioInputs": [
    "579408562507956"
  ],
  "maxItems": 3,
  "maxReelsPerAudio": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "audioInputs": [
        "579408562507956"
    ],
    "maxItems": 3,
    "maxReelsPerAudio": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/instagram-reels-audio-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 = {
    "audioInputs": ["579408562507956"],
    "maxItems": 3,
    "maxReelsPerAudio": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/instagram-reels-audio-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 '{
  "audioInputs": [
    "579408562507956"
  ],
  "maxItems": 3,
  "maxReelsPerAudio": 10
}' |
apify call automation-lab/instagram-reels-audio-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Reels Audio Scraper",
        "description": "🎵 Extract public Instagram Reels audio metadata, artists, usage signals, and representative Reels without login.",
        "version": "0.1",
        "x-build-id": "dWlA7JW8dbTJGOztz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~instagram-reels-audio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-instagram-reels-audio-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/automation-lab~instagram-reels-audio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-instagram-reels-audio-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/automation-lab~instagram-reels-audio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-instagram-reels-audio-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": [
                    "audioInputs"
                ],
                "properties": {
                    "audioInputs": {
                        "title": "🎵 Audio URLs or IDs",
                        "type": "array",
                        "description": "Public Instagram /reels/audio/ URLs or numeric audio IDs. Duplicates are removed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum audio records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique audio pages to return.",
                        "default": 10
                    },
                    "maxReelsPerAudio": {
                        "title": "Sample Reels per audio",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum representative public Reels embedded in each audio record.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Residential proxies can improve reliability when Instagram limits datacenter traffic."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```