# MyIP.ms Shopify Stores Scraper (`automation-lab/myip-ms-shopify-stores-scraper`) Actor

Extract Shopify-hosted store domains, IP/hosting metadata, traffic rank, popularity, and DNS records from MyIP.ms.

- **URL**: https://apify.com/automation-lab/myip-ms-shopify-stores-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## MyIP.ms Shopify Stores Scraper

Extract Shopify-hosted store domains from the public MyIP.ms hosting directory. This actor turns the MyIP.ms Shopify, Inc hosted-sites table into clean rows with store domains, IP addresses, hosting metadata, popularity estimates, DNS records, and source links.

Use it when you need a seed list of Shopify and DTC commerce websites for lead generation, market mapping, enrichment, competitor monitoring, or catalog and pricing workflows.

### What does MyIP.ms Shopify Stores Scraper do?

This actor reads MyIP.ms hosted-site directory pages and saves structured website records to an Apify dataset. The default input targets the Shopify, Inc owner page at `https://myip.ms/browse/sites/1/own/376714`.

It extracts the visible table data and the expanded detail row where MyIP.ms publishes extra signals such as daily visitors, reverse DNS, top-level host, DNS records, and record update time.

### Who is it for?

- 🧲 Lead generation teams building Shopify merchant lists.
- 🛒 Ecommerce agencies looking for Shopify prospects.
- 📊 Market intelligence teams mapping DTC brands and commerce infrastructure.
- 🔎 Data enrichment teams needing domain, IP, DNS, and hosting context.
- 🤖 Automation builders who want a clean seed dataset for follow-up crawlers.

### Why use this actor?

MyIP.ms is useful, but its directory is built for manual browsing. This actor converts those pages into exportable JSON, CSV, Excel, or API-ready records. You can plug the results into CRMs, enrichment tools, monitoring pipelines, or another Apify actor.

### How the source works

MyIP.ms lists websites by hosting owner and IP metadata. The Shopify, Inc page includes popular hosted domains, their IP addresses, country, traffic rank, popularity estimates, and related DNS information.

### Data fields

| Field | Description |
| --- | --- |
| `domain` | Domain shown in the MyIP.ms table. |
| `websiteUrl` | HTTPS website URL built from the domain. |
| `myipMsDetailUrl` | MyIP.ms detail page for the website. |
| `ipAddress` | Website IP address from the directory row. |
| `ipWhoisUrl` | MyIP.ms WHOIS link for the IP address. |
| `hostingCompany` | Hosting company / IP owner. |
| `hostingCountry` | Server location country. |
| `hostingCity` | Server city if MyIP.ms shows it. |
| `worldRank` | MyIP.ms world popularity rank. |
| `dailyVisitors` | Estimated visitors per day from the expanded row. |
| `reverseDnsHost` | Reverse DNS host value. |
| `topLevelHostname` | Top-level hostname when present. |
| `dnsRecords` | DNS record hostnames listed by MyIP.ms. |
| `recordUpdateTime` | MyIP.ms record update timestamp. |
| `sourceUrl` | Directory page used for the row. |
| `pageNumber` | Page number attempted by the actor. |
| `rowNumber` | Row number shown in the MyIP.ms table. |
| `scrapedAt` | Actor extraction timestamp. |

### How much does it cost to scrape Shopify stores from MyIP.ms?

The actor uses pay-per-event pricing. You pay a small run-start event plus a per-result event for each website record extracted. Apify shows the exact price before you run the actor.

### Input

The input is intentionally small:

```json
{
  "startUrls": ["https://myip.ms/browse/sites/1/own/376714"],
  "maxResults": 20,
  "maxPages": 1,
  "delayMs": 1000,
  "maxRequestRetries": 3
}
````

### Input options

- `startUrls` — MyIP.ms hosted-site directory URLs to scrape.
- `maxResults` — maximum records to save.
- `maxPages` — maximum directory pages to attempt per start URL.
- `delayMs` — polite delay between page requests.
- `maxRequestRetries` — retry limit for temporary failures.

### Output example

```json
{
  "domain": "shopify.com",
  "websiteUrl": "https://shopify.com",
  "myipMsDetailUrl": "https://myip.ms/view/sites/2379/shopify.com",
  "ipAddress": "23.227.38.33",
  "hostingCompany": "Shopify, Inc",
  "hostingCountry": "Canada",
  "worldRank": 122,
  "dailyVisitors": 2100000,
  "reverseDnsHost": "checkout.shopify.com",
  "sourceUrl": "https://myip.ms/browse/sites/1/own/376714",
  "pageNumber": 1,
  "scrapedAt": "2026-05-20T00:00:00.000Z"
}
```

### Step-by-step guide

1. Open the actor on Apify.
2. Keep the prefilled Shopify MyIP.ms URL or paste another MyIP.ms directory URL.
3. Set `maxResults` to the number of records you need.
4. Keep `maxPages` low for a quick test run.
5. Click **Start**.
6. Export the dataset as CSV, Excel, JSON, or access it by API.

### Tips for best results

- Start with 20 results to confirm the dataset shape.
- Increase `maxResults` only after a small run succeeds.
- Keep `delayMs` at 1000 ms or higher for polite crawling.
- Use the `myipMsDetailUrl` field for manual verification.
- Combine the dataset with store enrichment or website crawling actors.

### Pagination note

MyIP.ms may show human-verification pages for some paginated or export endpoints. The actor stops gracefully if that happens and keeps all records already extracted. The default prefill stays on page 1 because it is reliable and inexpensive for first runs.

### Integrations

You can connect this actor to:

- CRM imports for Shopify merchant outreach.
- Domain enrichment pipelines.
- Website screenshot or technology-detection actors.
- Pricing and catalog monitoring workflows.
- BI dashboards for Shopify market maps.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/myip-ms-shopify-stores-scraper').call({
  startUrls: ['https://myip.ms/browse/sites/1/own/376714'],
  maxResults: 20,
  maxPages: 1
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/myip-ms-shopify-stores-scraper').call(run_input={
    'startUrls': ['https://myip.ms/browse/sites/1/own/376714'],
    'maxResults': 20,
    'maxPages': 1,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~myip-ms-shopify-stores-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":["https://myip.ms/browse/sites/1/own/376714"],"maxResults":20,"maxPages":1}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or another MCP client through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/myip-ms-shopify-stores-scraper`

Claude Code CLI setup:

```bash
claude mcp add apify-myip-shopify "https://mcp.apify.com/?tools=automation-lab/myip-ms-shopify-stores-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-myip-shopify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/myip-ms-shopify-stores-scraper"
    }
  }
}
```

Example prompts:

- "Run the MyIP.ms Shopify Stores Scraper for 20 records and summarize the highest-traffic domains."
- "Export Shopify-hosted domains with daily visitors above 10,000."
- "Find DNS hosts repeated across the MyIP.ms Shopify sample."

### Legality

This actor extracts publicly available MyIP.ms directory pages. You are responsible for using the output lawfully, respecting MyIP.ms terms, and complying with privacy, outreach, and data-processing rules in your jurisdiction.

### FAQ

#### What is the best first run size?

Use the prefilled 20-record input first. It is enough to validate the columns, costs, and MyIP.ms availability before increasing volume.

### Troubleshooting

#### Why did I get fewer results than requested?

MyIP.ms can interrupt paginated requests with human verification. The actor saves rows already extracted and stops gracefully when that happens.

#### Why is `hostingCity` empty?

MyIP.ms often leaves the city column empty for Shopify-hosted records. The actor preserves the field when available.

#### Can I scrape non-Shopify MyIP.ms pages?

Yes. Paste another MyIP.ms hosted-site directory URL into `startUrls`. The output fields remain hosting-directory focused.

### Related scrapers

- https://apify.com/automation-lab/shopify-scraper
- https://apify.com/automation-lab/ecommerce-scraping-tool
- https://apify.com/automation-lab/website-content-crawler
- https://apify.com/automation-lab/domain-extractor

### Changelog

#### 0.1

Initial version for MyIP.ms Shopify hosted-site directory records.

### Notes

- Source pages are public MyIP.ms pages.
- The actor is HTTP-only and does not use a browser.
- The default input is designed for a cheap first run.
- Results include source URLs for auditability.
- Dataset rows are suitable for CSV and API workflows.

### Field quality checklist

- Domains are lowercased.
- URLs are absolute.
- Numeric ranks and visitor counts are parsed as numbers.
- DNS records are exported as an array.
- Duplicate domains are skipped across start URLs.

### Responsible use

Use the output as a starting dataset, not as a guarantee that every domain is an active Shopify storefront today. Validate high-value targets before outreach or business decisions.

### Support

If MyIP.ms changes its table layout or verification behavior, open an issue with a run URL and sample input so the actor can be adjusted.

# Actor input Schema

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

MyIP.ms hosted-site directory pages to scrape. The prefilled URL is the Shopify, Inc hosting-owner directory.

## `maxResults` (type: `integer`):

Maximum number of website records to save across all start URLs.

## `maxPages` (type: `integer`):

Maximum number of MyIP.ms table pages to attempt per start URL. The first page usually contains 50 records.

## `delayMs` (type: `integer`):

Polite delay between page requests.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for temporary network or HTTP failures.

## Actor input object example

```json
{
  "startUrls": [
    "https://myip.ms/browse/sites/1/own/376714"
  ],
  "maxResults": 20,
  "maxPages": 1,
  "delayMs": 1000,
  "maxRequestRetries": 3
}
```

# 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 = {
    "startUrls": [
        "https://myip.ms/browse/sites/1/own/376714"
    ],
    "maxResults": 20,
    "maxPages": 1,
    "delayMs": 1000,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/myip-ms-shopify-stores-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://myip.ms/browse/sites/1/own/376714"],
    "maxResults": 20,
    "maxPages": 1,
    "delayMs": 1000,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/myip-ms-shopify-stores-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://myip.ms/browse/sites/1/own/376714"
  ],
  "maxResults": 20,
  "maxPages": 1,
  "delayMs": 1000,
  "maxRequestRetries": 3
}' |
apify call automation-lab/myip-ms-shopify-stores-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyIP.ms Shopify Stores Scraper",
        "description": "Extract Shopify-hosted store domains, IP/hosting metadata, traffic rank, popularity, and DNS records from MyIP.ms.",
        "version": "0.1",
        "x-build-id": "ngMy3ycn8l5m4Fb0Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~myip-ms-shopify-stores-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-myip-ms-shopify-stores-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~myip-ms-shopify-stores-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-myip-ms-shopify-stores-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~myip-ms-shopify-stores-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-myip-ms-shopify-stores-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": {
                    "startUrls": {
                        "title": "MyIP.ms directory URLs",
                        "type": "array",
                        "description": "MyIP.ms hosted-site directory pages to scrape. The prefilled URL is the Shopify, Inc hosting-owner directory.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum store records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of website records to save across all start URLs.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of MyIP.ms table pages to attempt per start URL. The first page usually contains 50 records.",
                        "default": 1
                    },
                    "delayMs": {
                        "title": "Delay between pages (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Polite delay between page requests.",
                        "default": 1000
                    },
                    "maxRequestRetries": {
                        "title": "Request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for temporary network or HTTP failures.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
