# 🛒 Shopify Revenue Estimator — Store Intel (`nexgendata/shopify-analyzer`) Actor

Estimate any Shopify store's monthly revenue, detect themes, installed apps & traffic sources. SimilarWeb, Semrush & Store Leads alternative for ecommerce strategists, brand investors and competitive due diligence. From $0.008/store analyzed.

- **URL**: https://apify.com/nexgendata/shopify-analyzer.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** E-commerce, Business
- **Stats:** 9 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.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.

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

## Shopify Product Scraper by nexgendata

Extract Shopify store product catalogs including product titles, prices, variant details, inventory status, images, descriptions, vendor info, and collection assignments at scale. Built for dropshippers researching trending products and pricing and anyone who needs structured e-commerce data without the overhead of building a custom scraper.

### What This Actor Does

The Shopify Product Scraper connects to Shopify and extracts Shopify store product catalogs including product titles, prices, variant details, inventory status, images, descriptions, vendor info, and collection assignments. It handles pagination, rate limiting, and data normalization automatically so you get clean, structured JSON output ready for your database, dashboard, or analytics pipeline. No API keys to manage, no infrastructure to maintain.

### Who Uses This

Dropshippers researching trending products and pricing, competitive pricing intelligence tools, market researchers analyzing e-commerce niches, and agencies auditing client product catalogs. If you need e-commerce data at scale without building and maintaining your own extraction pipeline, this actor handles the heavy lifting.

### What You Get Back

Each run produces a structured dataset in JSON format. Every record includes all available fields from the source, normalized into a consistent schema. The data is immediately available for export in JSON, CSV, or Excel format, or you can push it directly to your data warehouse via Apify integrations with Google Sheets, Slack, Webhooks, and 50+ other platforms.

### How It Compares

Shopify Storefront API requires store-specific access tokens. Import.io and Diffbot charge $299+/month for e-commerce scraping. Manual product research across stores is impossibly slow. This actor delivers the same data at $5 per 1,000 products with zero monthly commitment, no API key management, and results available in seconds. Pay only for what you use.

### Sample Output

```json
{
  "source": "shopify-analyzer",
  "data": "Structured e-commerce data fields",
  "timestamp": "2024-03-29T12:00:00Z",
  "url": "https://example.com/source"
}
````

### Use Cases

Teams use the Shopify Product Scraper across a range of workflows. Analysts feed the output into business intelligence dashboards for real-time monitoring. Developers integrate it into automated data pipelines that run on daily or weekly schedules. Researchers use bulk exports for large-scale analysis projects. Marketing teams track competitive movements and industry trends. The structured output format means the data slots into virtually any downstream system with minimal transformation.

### Pricing: $5 per 1,000 Products

At $5/1K, processing 5,000 products costs $25.00 total. A daily pipeline pulling 500 products runs $2.50/day ($75/month). Compare that to building and maintaining your own scraping infrastructure, which typically costs $500-2,000/month in proxy fees, compute, and engineering time alone.

### FAQ

**How often can I run this?**
As often as you need. Schedule runs hourly, daily, or weekly through Apify's built-in scheduler, or trigger runs via API from your own systems.

**What format is the output?**
JSON by default, with one-click export to CSV or Excel. You can also push results directly to Google Sheets, webhooks, or any HTTP endpoint via Apify integrations.

**Do I need any API keys?**
No. The actor handles all authentication and access internally. Just configure your search parameters and run.

**Can I integrate this with my existing tools?**
Yes. Apify supports integrations with Zapier, Make, Google Sheets, Slack, and direct webhook delivery. You can also use the Apify API to pull results programmatically into any system.

### Related Shopify Actors

NexGenData offers a complete Shopify intelligence suite. Each actor targets a different use case:

| Actor | What It Does | Best For |
|-------|-------------|----------|
| [Shopify Revenue Estimator](https://apify.com/nexgendata/shopify-analyzer) | Revenue estimates, theme & app detection, traffic analysis | Competitive due diligence, investor research |
| [Shopify Product Extractor](https://apify.com/nexgendata/shopify-store-analyzer) | Full product catalogs with prices, variants, inventory | Dropshipping, price monitoring |
| [Shopify Product Scraper](https://apify.com/nexgendata/shopify-product-scraper) | Lightweight product data via /products.json | Quick product lookups, data pipelines |
| [Shopify Store Detector](https://apify.com/nexgendata/shopify-store-detector) | Theme, 55+ app fingerprints, tech stack, Shopify plan | Tech stack analysis, market research |
| [Shopify App Store Scraper](https://apify.com/nexgendata/shopify-app-store-scraper) | App listings, reviews, pricing, ratings from apps.shopify.com | App market intelligence, competitor tracking |

[Sign up for Apify](https://apify.com?fpr=2ayu9b) to get started with $5 in free credits every month.

### Related tools

- [Shopify Store Detector — Theme, Apps & Tech Stack Spy](https://apify.com/nexgendata/shopify-store-detector?fpr=2ayu9b)
- [Shopify Product Scraper — Full Catalogs](https://apify.com/nexgendata/shopify-product-scraper?fpr=2ayu9b)
- [Shopify Product Extractor — Catalog & Prices](https://apify.com/nexgendata/shopify-store-analyzer?fpr=2ayu9b)
- [₿ Crypto Price Tracker — Real-Time & Alerts](https://apify.com/nexgendata/crypto-price-tracker?fpr=2ayu9b)

***

### Why Shopify Analyzer Beats SimilarWeb, Sensor Tower, Jungle Scout & SpyFu

| Feature | NexGenData Shopify Analyzer | SimilarWeb | Sensor Tower | Jungle Scout | SpyFu |
|---|---|---|---|---|---|
| Cost | $0.005 / store, pay-per-event | $199-499 / month | $$$$ enterprise | $49-129 / month | $39-79 / month |
| Shopify-specific signals | Yes — theme, app stack, product velocity | Generic web traffic | Mobile-app focus | Amazon only | SEO / SEM focus |
| Revenue estimation | Yes — order-velocity model | Yes (paid tier) | No | Amazon only | No |
| Bulk export | JSON / CSV / Excel | Plan-gated | Plan-gated | Plan-gated | CSV |
| App / tech stack detected | Yes — Klaviyo, Yotpo, ReCharge, etc. | Yes | Yes | No | No |
| Auth | Apify token | Account + plan | Account + plan | Account + plan | Account + plan |
| Monthly minimum | None | $199+ | $$$$ | $49+ | $39+ |

Shopify Analyzer is a drop-in **alternative to** SimilarWeb's Shopify-vertical reports and a much **cheaper than** Sensor Tower / Jungle Scout angle for DTC competitive intel. Teams pick it **instead of** building a custom Shopify-detection + revenue-model pipeline because every store domain comes back with traffic, revenue estimate, app stack, and theme in a single call — what would otherwise take 3-4 separate paid tools.

### Related NexGenData Commerce Actors

| Use case | Actor |
|----------|-------|
| Shopify store product scraper | [shopify-product-scraper](https://apify.com/nexgendata/shopify-product-scraper?fpr=2ayu9b) |
| Shopify store analyzer (revenue + traffic) | [shopify-store-analyzer](https://apify.com/nexgendata/shopify-store-analyzer?fpr=2ayu9b) |
| Shopify store detector (BuiltWith alt) | [shopify-store-detector](https://apify.com/nexgendata/shopify-store-detector?fpr=2ayu9b) |
| Amazon product scraper | [amazon-product-scraper](https://apify.com/nexgendata/amazon-product-scraper?fpr=2ayu9b) |
| Google Shopping price tracker | [google-shopping-scraper](https://apify.com/nexgendata/google-shopping-scraper?fpr=2ayu9b) |
| SaaS / DTC pricing tracker | [saas-pricing-tracker](https://apify.com/nexgendata/saas-pricing-tracker?fpr=2ayu9b) |
| JD.com product scraper (China commerce) | [jd-com-product-scraper](https://apify.com/nexgendata/jd-com-product-scraper?fpr=2ayu9b) |
| Indie Hackers product launches | [indie-hackers-products-tracker](https://apify.com/nexgendata/indie-hackers-products-tracker?fpr=2ayu9b) |
| Product Hunt daily launches | [product-hunt-launches-scraper](https://apify.com/nexgendata/product-hunt-launches-scraper?fpr=2ayu9b) |
| E-commerce intelligence MCP for AI | [ecommerce-intelligence-mcp-server](https://apify.com/nexgendata/ecommerce-intelligence-mcp-server?fpr=2ayu9b) |

Browse the full NexGenData catalog of 260+ actors at https://apify.com/nexgendata?fpr=2ayu9b

# Actor input Schema

## `store_urls` (type: `array`):

Shopify store URLs to analyze. Accepts a list of URLs (each can be a string OR a {url: '...'} dict) OR a single URL string OR a comma/newline-separated list. Also accepts these alternative field names: urls, startUrls, storeUrls, shopifyStores, store\_url, url, storeUrl.

## `max_products` (type: `integer`):

Maximum products to fetch per store (Shopify limits to 250 per request)

## `urls` (type: `array,string`):

Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated.

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

Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated.

## `storeUrls` (type: `array,string`):

Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated.

## `shopifyStores` (type: `array,string`):

Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated.

## `store_url` (type: `string`):

Alternative — a single value when you only need one. Comma-separated values are auto-split.

## `url` (type: `string`):

Alternative — a single value when you only need one. Comma-separated values are auto-split.

## `storeUrl` (type: `string`):

Alternative — a single value when you only need one. Comma-separated values are auto-split.

## Actor input object example

```json
{
  "store_urls": [
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "max_products": 250
}
```

# 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 = {
    "store_urls": [
        {
            "url": "https://www.allbirds.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/shopify-analyzer").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 = { "store_urls": [{ "url": "https://www.allbirds.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/shopify-analyzer").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 '{
  "store_urls": [
    {
      "url": "https://www.allbirds.com"
    }
  ]
}' |
apify call nexgendata/shopify-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛒 Shopify Revenue Estimator — Store Intel",
        "description": "Estimate any Shopify store's monthly revenue, detect themes, installed apps & traffic sources. SimilarWeb, Semrush & Store Leads alternative for ecommerce strategists, brand investors and competitive due diligence. From $0.008/store analyzed.",
        "version": "0.0",
        "x-build-id": "TD2y7PWB8dACxluJk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~shopify-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-shopify-analyzer",
                "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/nexgendata~shopify-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-shopify-analyzer",
                "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/nexgendata~shopify-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-shopify-analyzer",
                "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": {
                    "store_urls": {
                        "title": "Shopify Store URLs",
                        "type": "array",
                        "description": "Shopify store URLs to analyze. Accepts a list of URLs (each can be a string OR a {url: '...'} dict) OR a single URL string OR a comma/newline-separated list. Also accepts these alternative field names: urls, startUrls, storeUrls, shopifyStores, store_url, url, storeUrl.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "max_products": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum products to fetch per store (Shopify limits to 250 per request)",
                        "default": 250
                    },
                    "urls": {
                        "title": "urls (alias for `store_urls`)",
                        "description": "Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated."
                    },
                    "startUrls": {
                        "title": "startUrls (alias for `store_urls`)",
                        "description": "Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated."
                    },
                    "storeUrls": {
                        "title": "storeUrls (alias for `store_urls`)",
                        "description": "Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated."
                    },
                    "shopifyStores": {
                        "title": "shopifyStores (alias for `store_urls`)",
                        "description": "Alternative name for `store_urls`. Accepts a list OR a single string OR comma/newline-separated."
                    },
                    "store_url": {
                        "title": "store_url (single-value alias for `store_urls`)",
                        "type": "string",
                        "description": "Alternative — a single value when you only need one. Comma-separated values are auto-split."
                    },
                    "url": {
                        "title": "url (single-value alias for `store_urls`)",
                        "type": "string",
                        "description": "Alternative — a single value when you only need one. Comma-separated values are auto-split."
                    },
                    "storeUrl": {
                        "title": "storeUrl (single-value alias for `store_urls`)",
                        "type": "string",
                        "description": "Alternative — a single value when you only need one. Comma-separated values are auto-split."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
