# ETF.com Scraper | ETF Data Holdings and Returns (`parseforge/etf-com-scraper`) Actor

Pull ETF data from ETF.com including ticker, issuer, expense ratio, AUM, holdings, sector breakdown, returns, dividend yield, and benchmark. Compare thousands of ETFs for portfolio analysis, fund research, finance dashboards, and investment screening at scale across markets.

- **URL**: https://apify.com/parseforge/etf-com-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, News, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📈 ETF Directory Scraper

> 🚀 **Export ETF data with expense ratios, AUM, returns, and categories in seconds.** No account needed - just run and download.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per record · **4,500+ ETFs** · **US market coverage**

Pull structured data from the ETF Database screener - tickers, fund names, issuers, expense ratios, assets under management, categories, index tracked, YTD returns, 1-year returns, and average daily volume. Data is collected in real time via the ETF Database public API and detail pages.

The dataset covers all US-listed ETFs tracked by ETF Database (etfdb.com), sourced from live market data. Every record includes the core metrics passive investors and financial researchers need most.

---

### Target Audience / Use Cases

| Audience | Use Case |
|---|---|
| Passive investors | Screen ETFs by expense ratio, AUM, and category |
| Financial researchers | Build ETF comparison datasets |
| Portfolio managers | Track universe of available ETFs and performance |
| Fintech developers | Power ETF search and filter tools |
| Data journalists | Analyze ETF industry trends and market data |
| Educators | Teach passive investing concepts with real data |

---

### 📋 What the ETF Directory Scraper does

- Fetches all 4,500+ US-listed ETFs from the ETF Database screener API
- Enriches each record with issuer, expense ratio, inception date, and index tracked from ETF detail pages
- Supports sorting by AUM, YTD return, or average volume
- Filters by asset class (Equity, Fixed Income, Commodity, Currency, Alternatives)
- Respects free/paid user limits automatically
- Returns clean, structured JSON/CSV ready for download

> 💡 **Why it matters:** ETF data is scattered across dozens of fund company websites. This scraper unifies it into one flat dataset you can filter, sort, and analyze in minutes.

---

### 🎬 Full Demo

🚧 Coming soon

---

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | 10 | Number of ETFs to return. Free users limited to 10. |
| `assetClass` | string | All | Filter by asset class: Equity, Fixed Income, Commodity, Currency, Alternatives, Asset Allocation |
| `sortBy` | string | assets | Sort field: `assets` (AUM), `ytd` (YTD return), `average_volume` |

**Example 1 - Top 100 ETFs by AUM:**
```json
{
  "maxItems": 100,
  "sortBy": "assets"
}
````

**Example 2 - Top 50 Bond ETFs:**

```json
{
  "maxItems": 50,
  "assetClass": "Fixed Income",
  "sortBy": "assets"
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 records.

***

### 📊 Output

| Field | Type | Example |
|---|---|---|
| 📌 `ticker` | string | `"VOO"` |
| 📛 `name` | string | `"Vanguard S&P 500 ETF"` |
| 🔗 `url` | string | `"https://etfdb.com/etf/VOO/"` |
| 🏢 `issuer` | string | `"Vanguard"` |
| 💰 `expenseRatio` | number | `0.0003` |
| 💵 `aum` | number | `956804` (millions USD) |
| 🗂️ `category` | string | `"Large Cap Growth Equities"` |
| 📦 `assetClass` | string | `"Equity"` |
| 📈 `ytdReturn` | number | `9.23` (%) |
| 📊 `oneYearReturn` | number | `26.59` (%) |
| 📉 `avgVolume` | number | `9301940` |
| 🧭 `indexTracked` | string | `"S&P 500 Index"` |
| 🗓️ `inceptionDate` | string | `"Sep 07, 2010"` |
| ⏱️ `scrapedAt` | string | `"2026-05-22T02:17:44.069Z"` |
| ❌ `error` | string | null |

**Sample records:**

```json
[
  {
    "ticker": "VOO",
    "name": "Vanguard S&P 500 ETF",
    "url": "https://etfdb.com/etf/VOO/",
    "issuer": "Vanguard",
    "expenseRatio": 0.0003,
    "aum": 956804,
    "category": "Large Cap Growth Equities",
    "assetClass": "Equity",
    "ytdReturn": 9.23,
    "oneYearReturn": 26.59,
    "avgVolume": 9301940,
    "indexTracked": "S&P 500 Index",
    "inceptionDate": "Sep 07, 2010",
    "scrapedAt": "2026-05-22T02:17:44.069Z"
  },
  {
    "ticker": "IVV",
    "name": "iShares Core S&P 500 ETF",
    "url": "https://etfdb.com/etf/IVV/",
    "issuer": "BlackRock, Inc.",
    "expenseRatio": 0.0003,
    "aum": 817532,
    "category": "Large Cap Growth Equities",
    "assetClass": "Equity",
    "ytdReturn": 9.23,
    "oneYearReturn": 26.6,
    "avgVolume": 7973494,
    "indexTracked": "S&P 500 Index",
    "inceptionDate": "May 15, 2000",
    "scrapedAt": "2026-05-22T02:17:44.631Z"
  }
]
```

***

### ✨ Why choose this Actor

- Zero configuration - runs out of the box with no API keys or accounts
- Real-time data from ETF Database - not cached or stale
- Complete field set - 14 fields per ETF including expense ratio, AUM, and 1-year return
- Asset class filtering - drill down into equity, bonds, commodities, or alternatives
- Handles 4,500+ ETFs - full US ETF universe in one dataset
- Clean numerics - AUM in millions, expense ratio as decimal, returns as percentage floats

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Financial APIs |
|---|---|---|---|
| No API key required | Yes | Yes | No |
| 4,500+ ETFs | Yes | Slow | Varies |
| Expense ratio included | Yes | Manual | Sometimes |
| Category classification | Yes | Manual | Rarely |
| Index tracked | Yes | Manual | Rarely |
| Export to CSV/JSON | One click | Manual | Manual |
| Cost | Free (10 items) / Paid | Free but time-consuming | Monthly subscription |

***

### 🚀 How to use

1. Go to the [ETF Directory Scraper](https://apify.com/parseforge/etf-com-scraper) on Apify
2. Click **Try for free**
3. Set `maxItems`, optionally filter by `assetClass` or change `sortBy`
4. Click **Start**
5. Download results as JSON, CSV, Excel, or XML

***

### 💼 Business use cases

#### ETF Screening and Selection

Build automated screeners that filter by expense ratio thresholds, AUM minimums, and category. Identify the lowest-cost ETFs in any asset class.

#### Portfolio Research and Construction

Compare ETFs across the same category side by side. Analyze tracking differences, issuer concentration, and fund age via inception date.

#### Passive Investing Analysis

Track the evolution of the ETF industry - average expense ratios by category, AUM growth by issuer, and adoption of index-based strategies.

#### Financial Education

Use real ETF data to teach students about passive investing, index funds, and portfolio diversification with up-to-date market facts.

***

### 🔌 Automating ETF Directory Scraper

Connect to Make (formerly Integromat), Zapier, or any webhook to automate ETF data collection:

- **Make:** Trigger the actor on a schedule, send results to Google Sheets
- **Zapier:** New dataset item triggers Slack notification or database insert
- **REST API:** Call via `https://api.apify.com/v2/acts/parseforge~etf-com-scraper/runs` with your token

***

### 🌟 Beyond business use cases

#### Academic Research

Study passive investing adoption, expense ratio compression over time, or ETF market concentration by issuer.

#### Creative Projects

Build a personal ETF discovery tool or portfolio optimizer using real fund data.

#### Non-profit and Education

Teach financial literacy with real market data - compare low-cost index funds vs. expensive active funds.

#### Personal Experimentation

Explore the universe of ETFs - find niche thematic ETFs, newly launched funds, or the highest-yield bond ETFs.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your favorite AI assistant:

> "How do I use the ParseForge ETF Directory Scraper to find the cheapest S\&P 500 ETFs?"
> "What ETF data fields does the Apify etf-com-scraper return?"
> "How do I filter ETFs by asset class with the ParseForge scraper?"

***

### ❓ Frequently Asked Questions

**🔍 Where does the data come from?**
Data is collected in real time from ETF Database (etfdb.com), which aggregates data from fund companies, exchanges, and market data providers.

**💰 How is AUM measured?**
AUM is reported in millions of USD as shown on ETF Database.

**📊 What does expenseRatio represent?**
It is the annual fund operating expense as a decimal. For example, 0.0003 means 0.03% (3 basis points per year).

**🆓 How many ETFs can free users get?**
Free users get up to 10 ETFs. [Upgrade](https://console.apify.com/sign-up?fpr=vmoqkp) to access the full 4,500+ ETF universe.

**📅 How current is the data?**
Data is scraped live at the time of your run. ETF Database updates daily.

**🏢 Which issuers are included?**
All issuers on ETF Database are included - Vanguard, BlackRock, State Street, Invesco, Fidelity, and hundreds more.

**🧭 What does indexTracked mean?**
It is the benchmark index the ETF aims to replicate. Active ETFs may have null here.

**🗂️ What categories are available?**
ETF Database uses its own category taxonomy - Large Cap Growth Equities, Corporate Bonds, Gold, etc. Use the `assetClass` filter for broad groupings.

**📈 Are returns real-time?**
Returns reflect the most recent data available on ETF Database at run time.

**🔢 How many ETFs are in the database?**
The ETF Database currently tracks 4,591 US-listed ETFs.

***

### 🔌 Integrate with any app

Export to Google Sheets, Airtable, PostgreSQL, MongoDB, Slack, Excel, or any REST API. Apify supports webhook triggers, scheduled runs, and direct API access.

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [OurAirports Global Airport Database Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport data with IATA codes, coordinates, and runway info |
| [Stock Analysis Scraper](https://apify.com/parseforge) | Public company financials and stock data |
| [Financial Data Scraper](https://apify.com/parseforge) | Broad financial market datasets |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more financial and data scrapers.

***

**Disclaimer:** This tool collects publicly available data from ETF Database for research and informational purposes. Always verify data with official fund documents before making investment decisions. ETF data changes daily - run frequency should match your data freshness requirements.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `assetClass` (type: `string`):

Filter ETFs by asset class. Leave empty to scrape all asset classes.

## `sortBy` (type: `string`):

Field to sort ETFs by.

## Actor input object example

```json
{
  "maxItems": 10,
  "sortBy": "assets"
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10,
    "assetClass": "",
    "sortBy": "assets"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/etf-com-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 = {
    "maxItems": 10,
    "assetClass": "",
    "sortBy": "assets",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/etf-com-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 '{
  "maxItems": 10,
  "assetClass": "",
  "sortBy": "assets"
}' |
apify call parseforge/etf-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ETF.com Scraper | ETF Data Holdings and Returns",
        "description": "Pull ETF data from ETF.com including ticker, issuer, expense ratio, AUM, holdings, sector breakdown, returns, dividend yield, and benchmark. Compare thousands of ETFs for portfolio analysis, fund research, finance dashboards, and investment screening at scale across markets.",
        "version": "0.1",
        "x-build-id": "rFi2NKTCpSVLMBkFV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~etf-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-etf-com-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/parseforge~etf-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-etf-com-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/parseforge~etf-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-etf-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "assetClass": {
                        "title": "Asset Class",
                        "enum": [
                            "",
                            "Equity",
                            "Fixed Income",
                            "Commodity",
                            "Currency",
                            "Alternatives",
                            "Asset Allocation"
                        ],
                        "type": "string",
                        "description": "Filter ETFs by asset class. Leave empty to scrape all asset classes."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "assets",
                            "ytd",
                            "average_volume"
                        ],
                        "type": "string",
                        "description": "Field to sort ETFs by."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
