# Shopify Store Analyzer (`automation-lab/shopify-store-analyzer`) Actor

Audit Shopify stores for apps, pixels, catalog signals, contacts, promotions, and sales opportunity scoring.

- **URL**: https://apify.com/automation-lab/shopify-store-analyzer.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **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

## Shopify Store Analyzer

Audit Shopify stores for apps, pixels, catalog signals, contact details, promotions, and agency opportunity scores.

### What does Shopify Store Analyzer do?

Shopify Store Analyzer turns a list of public Shopify storefront URLs into structured ecommerce intelligence.

It fetches each storefront with HTTP, checks whether the site looks like Shopify, samples the public product catalog when available, detects common apps and marketing pixels, extracts social/contact signals, and returns a score that helps prioritize sales or competitive research.

Use it when you need a quick view of what a Shopify merchant is using without manually opening source code, product pages, contact pages, and tracking scripts.

### Who is it for?

- 🛍️ Ecommerce agencies auditing prospective Shopify clients.
- 📈 DTC operators comparing competitors and category leaders.
- 💼 SaaS sales teams qualifying merchants for outreach.
- 🧾 Investors doing lightweight diligence on Shopify brands.
- 🧪 Growth teams checking pixels, apps, and promotional tactics.

### Why use this actor?

Manual Shopify audits are repetitive.

You usually need to check homepage markup, theme hints, app scripts, product feeds, contacts, social links, and promo language.

This actor automates those first-pass checks and returns a normalized dataset for spreadsheets, CRMs, lead scoring, or research dashboards.

### What data can it extract?

| Field group | Examples |
| --- | --- |
| Store identity | input URL, final URL, normalized domain, title, shop name |
| Shopify detection | `isShopify`, confidence score, myshopify domain hints |
| Theme hints | Shopify theme name and theme ID when exposed |
| Catalog summary | sampled product count and product examples from `/products.json` |
| App detection | Klaviyo, Yotpo, Judge.me, Loox, Recharge, Gorgias, Okendo, Stamped, Smile.io |
| Pixel detection | Meta Pixel, TikTok Pixel, Pinterest Tag |
| Analytics | Google Tag Manager, Google Analytics 4, Hotjar, Triple Whale |
| Lead signals | emails, phone numbers, social links, contact page, about page |
| Commercial signals | payment hints, shipping hints, promo signals |
| Scores | confidence score and agency opportunity score |

### How much does it cost to analyze Shopify stores?

The actor uses pay-per-event pricing.

You pay a $0.005 run start fee plus a per-store event for each store audit saved to the dataset.

BRONZE pricing is $0.00019203 per store analyzed, with canonical Apify tier discounts for higher plans.

### Input

The main input is `startUrls`.

Paste Shopify storefront URLs.

Examples:

```json
{
  "startUrls": [
    { "url": "https://www.deathwishcoffee.com" },
    { "url": "https://www.allbirds.com" }
  ],
  "maxStores": 2,
  "maxProductsPerStore": 25,
  "crawlContactPages": true
}
````

### Input fields

#### `startUrls`

A list of public store URLs.

Use full `https://` storefront URLs for best compatibility with Apify's URL input editor.

#### `maxStores`

Caps how many supplied URLs are processed.

Use this for cheap test runs or large lead lists.

#### `maxProductsPerStore`

Controls the sample size requested from `/products.json`.

Some stores disable or limit this endpoint, so the output may include a warning.

#### `crawlContactPages`

When enabled, the actor fetches likely contact and about pages on the same domain.

This improves emails, phones, and lead research fields.

### Output

Each dataset item is one Shopify store audit.

The item includes the input URL, normalized domain, Shopify confidence, detected technologies, contact details, product samples, and scoring.

### Example output

```json
{
  "inputUrl": "https://www.deathwishcoffee.com",
  "normalizedDomain": "deathwishcoffee.com",
  "isShopify": true,
  "shopName": "Death Wish Coffee Company",
  "productCount": 25,
  "appsDetected": ["Klaviyo", "Shop Pay"],
  "pixelsDetected": ["Meta Pixel"],
  "analyticsTags": ["Google Tag Manager"],
  "emailAddresses": ["support@example.com"],
  "socialLinks": ["https://www.instagram.com/example"],
  "confidenceScore": 90,
  "agencyOpportunityScore": 78
}
```

### Product catalog notes

Many Shopify stores expose a public `/products.json` endpoint.

This actor uses that endpoint for product samples.

It does not try to bypass storefront restrictions.

If a store blocks the endpoint, the run still returns homepage, technology, and contact signals with a warning.

### App and pixel detection

The actor detects common ecommerce tools from public HTML and script references.

Detection is evidence-based.

It looks for known signatures such as Klaviyo, Yotpo, Judge.me, Loox, Recharge, Meta Pixel, TikTok Pixel, Pinterest Tag, GTM, and GA4.

### Agency opportunity score

The agency opportunity score is a heuristic from 0 to 100.

It rewards stores that expose strong commerce and marketing signals:

- Shopify confirmation.
- App stack depth.
- Pixels and analytics tags.
- Contactability.
- Promotions.
- Catalog presence.

Use it for prioritization, not as a financial estimate.

### Confidence score

The confidence score estimates how strongly the evidence indicates a Shopify store.

Signals include Shopify CDN usage, Shopify JavaScript objects, myshopify domains, product feed availability, and technology evidence.

### Common use cases

- Build a ranked Shopify prospect list.
- Compare app stacks in a niche.
- Find merchants using or missing specific pixels.
- Pull social and contact links for outreach.
- Audit whether a prospect has product feed and promotion signals.
- Check competitor Shopify themes and marketing tools.

### How to run it

1. Open the actor on Apify.
2. Paste one or more Shopify store URLs.
3. Keep the default product sample size for a cheap first run.
4. Enable contact page crawling if you need lead fields.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

- Use store homepages rather than product URLs.
- Keep the first run small to validate your list.
- Increase `maxProductsPerStore` when catalog intelligence is more important.
- Disable contact page crawling for the fastest technology-only checks.
- Review warnings to understand stores that block `/products.json`.

### 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/shopify-store-analyzer').call({
  startUrls: [{ url: 'https://www.deathwishcoffee.com' }],
  maxStores: 1,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/shopify-store-analyzer').call(run_input={
    'startUrls': [{'url': 'https://www.deathwishcoffee.com'}],
    'maxStores': 1,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~shopify-store-analyzer/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.deathwishcoffee.com"}],"maxStores":1}'
```

### Integrations

Send output to:

- Google Sheets for prospect review.
- HubSpot or Salesforce for sales workflows.
- Airtable for enrichment queues.
- BI tools for competitor dashboards.
- Webhooks for automated alerts when app stacks change.

### MCP usage

Use this actor from AI tools through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/shopify-store-analyzer`

Claude Code setup:

```bash
claude mcp add apify-shopify-store-analyzer https://mcp.apify.com/?tools=automation-lab/shopify-store-analyzer
```

JSON MCP server config:

```json
{
  "mcpServers": {
    "apify-shopify-store-analyzer": {
      "url": "https://mcp.apify.com/?tools=automation-lab/shopify-store-analyzer"
    }
  }
}
```

Example prompts:

- "Analyze these Shopify stores and rank outreach priority."
- "Which stores use Meta Pixel but do not show Klaviyo?"
- "Summarize app stack differences between these competitors."

### Data quality and limitations

The actor only uses public storefront data.

It does not log in.

It does not use paid Shopify APIs.

It does not guarantee exact revenue, traffic, install dates, or private app settings.

Some storefronts customize or block public endpoints.

Warnings are included when a signal cannot be collected.

### Legality

This actor reads publicly available web pages and public JSON endpoints.

Make sure your use complies with applicable laws, website terms, privacy obligations, and Apify's terms.

Do not use extracted contact data for spam or unlawful outreach.

### FAQ

#### Can this actor estimate revenue?

No. It reports public evidence from storefront pages and product feeds. Revenue or traffic estimates are not included unless a reliable public data source is added later.

#### Does it need a Shopify API key?

No. It uses public storefront HTML and public Shopify endpoints only.

### Troubleshooting

#### Why is productCount null?

The store may block `/products.json`, return a non-standard response, or hide catalog data.

The actor still returns homepage and technology signals.

#### Why are app detections missing?

Some apps load only after user interaction or from tag managers.

This HTTP-first actor reports public source evidence and does not execute every browser-side script.

#### Why is the confidence score below 100 for a real Shopify store?

A store can be heavily customized or hide common Shopify markers.

Confidence is a signal score, not a binary guarantee.

### Related scrapers

- https://apify.com/automation-lab/shopify-scraper
- https://apify.com/automation-lab/shopify-store-leads-scraper
- https://apify.com/automation-lab/shopify-klaviyo-gap-leads-scraper

### Changelog

#### 0.1

Initial version with HTTP storefront audits, product sampling, app/pixel detection, contacts, and scoring.

### Support

If a store URL fails unexpectedly, include the run ID and input URL when reporting the issue.

### Responsible usage

Start with small batches.

Respect rate limits and merchant privacy.

Use the output to guide research, not to make unsupported claims.

### Field reference

`inputUrl`

Original URL supplied by the user.

`normalizedDomain`

Domain normalized for grouping.

`finalUrl`

Final URL after redirects.

`isShopify`

Whether public evidence suggests Shopify.

`technologyEvidence`

Evidence snippets supporting app, pixel, analytics, and script-host detection.

`warnings`

Non-fatal collection issues.

# Actor input Schema

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

Shopify storefront URLs or domains to audit. Enter one or more public store homepages.

## `maxStores` (type: `integer`):

Maximum number of supplied store URLs to analyze in this run.

## `maxProductsPerStore` (type: `integer`):

How many products to request from each store's public /products.json endpoint for catalog summary and samples.

## `crawlContactPages` (type: `boolean`):

Fetch likely contact/about pages on the same domain to find emails, phones, and social links. Keep enabled for lead research.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.deathwishcoffee.com"
    },
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "maxStores": 2,
  "maxProductsPerStore": 20,
  "crawlContactPages": true
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shopify-store-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 = { "startUrls": [
        { "url": "https://www.deathwishcoffee.com" },
        { "url": "https://www.allbirds.com" },
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Analyzer",
        "description": "Audit Shopify stores for apps, pixels, catalog signals, contacts, promotions, and sales opportunity scoring.",
        "version": "0.1",
        "x-build-id": "MkiVPD3U9ZbLUCrC9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~shopify-store-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-shopify-store-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/automation-lab~shopify-store-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-shopify-store-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/automation-lab~shopify-store-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-shopify-store-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Store URLs",
                        "type": "array",
                        "description": "Shopify storefront URLs or domains to audit. Enter one or more public store homepages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxStores": {
                        "title": "Maximum stores",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of supplied store URLs to analyze in this run.",
                        "default": 2
                    },
                    "maxProductsPerStore": {
                        "title": "Product sample size per store",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "How many products to request from each store's public /products.json endpoint for catalog summary and samples.",
                        "default": 20
                    },
                    "crawlContactPages": {
                        "title": "Crawl contact and about pages",
                        "type": "boolean",
                        "description": "Fetch likely contact/about pages on the same domain to find emails, phones, and social links. Keep enabled for lead research.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
