# Ahrefs Free Website Stats Scraper (`automation-lab/ahrefs-free-website-stats-scraper`) Actor

Scrape public AhrefsTop domain stats: traffic, Domain Rating, backlinks, countries, keywords, and competitors for SEO monitoring.

- **URL**: https://apify.com/automation-lab/ahrefs-free-website-stats-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools
- **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

## Ahrefs Free Website Stats Scraper

Scrape public AhrefsTop website stats for any list of domains. The actor returns domain-level SEO signals such as organic traffic, traffic value, Domain Rating, referring domains, backlink-related data, top countries, top keywords, competitors, and similarly ranked websites.

### What does Ahrefs Free Website Stats Scraper do?

Ahrefs Free Website Stats Scraper turns public website stats pages into structured datasets.

It accepts domains such as `apify.com`, `shopify.com`, or `https://ahrefstop.com/websites/stripe.com`.

For every input domain it follows the public Ahrefs redirect and extracts visible metrics from the free AhrefsTop page.

Use it when you need repeatable SEO snapshots without manually opening each domain page.

### Who is it for?

SEO agencies use it to monitor client and competitor domains.

Link builders use it to qualify outreach prospects.

Affiliate teams use it to benchmark niche competitors.

Content teams use it to find domains with growing organic visibility.

Competitive-intelligence operators use it to enrich company lists with traffic and backlink signals.

### Why use this actor?

- Bulk scrape public domain stats from AhrefsTop.
- Normalize domains and URLs automatically.
- Export data as JSON, CSV, Excel, XML, or HTML through Apify datasets.
- Run on a schedule for recurring monitoring.
- Integrate results into Google Sheets, CRMs, dashboards, and lead-scoring workflows.

### Data you can extract

| Field | Description |
| --- | --- |
| `domain` | Normalized input domain |
| `sourceUrl` | Final AhrefsTop page URL |
| `organicTraffic` | Latest visible organic traffic number |
| `trafficValue` | Latest visible traffic value number |
| `domainRating` | Visible Domain Rating value |
| `referringDomains` | Latest linking websites / referring-domain trend value when exposed |
| `backlinks` | Visible backlink value when exposed |
| `topCountries` | Country traffic split objects |
| `topKeywords` | Keyword, volume, traffic, and position rows |
| `topCompetitors` | Competing websites shown on the page |
| `similarlyRankedWebsites` | Similar traffic-rank domains |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Ahrefs website stats?

This actor uses pay-per-event pricing.

There is a small start charge for each run and a per-domain charge for every saved dataset item.

The final price shown in Apify billing depends on the live pricing tier on the actor page.

Use a small `maxItems` value for your first run, then scale after checking the output.

### How to use Ahrefs Free Website Stats Scraper

1. Open the actor on Apify.
2. Add domains or AhrefsTop URLs to `domains`.
3. Keep `maxConcurrency` modest for stable scraping.
4. Click **Start**.
5. Download the dataset or connect it to your automation.

### Input example

```json
{
  "domains": [
    "apify.com",
    "stripe.com",
    "https://ahrefstop.com/websites/shopify.com"
  ],
  "maxItems": 3,
  "maxConcurrency": 3,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Output example

```json
{
  "domain": "apify.com",
  "sourceUrl": "https://ahrefstop.com/websites/apify.com",
  "organicTraffic": 355203,
  "trafficValue": 169333,
  "domainRating": 80,
  "topCountries": [
    { "countryCode": "US", "traffic": 79721, "trafficShare": 0.224 }
  ],
  "scrapedAt": "2026-07-04T00:00:00.000Z"
}
```

### Input fields

#### Domains

Add domains, hostnames, Ahrefs URLs, or AhrefsTop URLs.

The actor removes `www.` and normalizes URLs to the public website stats endpoint.

#### Maximum domains to process

`maxItems` is a safety cap. It prevents accidental large runs.

#### Maximum concurrency

`maxConcurrency` controls how many pages are requested at once.

Use a lower value for very large batches or repeated monitoring jobs.

#### Include raw HTML

Turn this on only when debugging. Raw HTML increases dataset size.

#### Proxy configuration

The public pages usually work without a proxy. If your run is blocked, enable Apify Proxy.

### Output fields explained

`organicTraffic` and `trafficValue` come from the latest visible chart values embedded in the page.

`domainRating` is parsed from the backlink profile section.

`topCountries` comes from embedded page data.

`topKeywords`, `topCompetitors`, and `similarlyRankedWebsites` are parsed from visible tables.

Some locked Ahrefs metrics may be unavailable on certain pages; those fields are returned as `null`.

### Tips for reliable runs

- Start with 3-10 domains.
- Use exact domains, not full paths, unless you are pasting AhrefsTop URLs.
- Keep concurrency between 3 and 5 for regular monitoring.
- Schedule separate runs for very large client lists.
- Store previous datasets if you want to compare month-over-month changes.

### SEO agency workflow

Upload a list of prospect or competitor domains.

Export the dataset to Google Sheets.

Filter by Domain Rating, traffic, and country share.

Prioritize targets with meaningful traffic and relevant keyword overlap.

### Link-building workflow

Add outreach prospects to the actor.

Use Domain Rating and linking-website signals to remove weak targets.

Use top keywords to understand topical relevance before outreach.

Send qualified domains to your CRM or outreach tool.

### Competitive monitoring workflow

Create a scheduled Apify task.

Run it weekly or monthly against the same competitor list.

Compare exported datasets over time.

Trigger alerts when traffic, rank, or referring-domain signals change.

### Integrations

Connect the dataset to Google Sheets for analyst review.

Send results to Make or Zapier for lead scoring.

Store snapshots in BigQuery, Snowflake, or a warehouse.

Feed domains into other automation-lab SEO actors for enrichment.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ahrefs-free-website-stats-scraper').call({
  domains: ['apify.com', 'stripe.com'],
  maxItems: 2,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ahrefs-free-website-stats-scraper').call(run_input={
    'domains': ['apify.com', 'stripe.com'],
    'maxItems': 2,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~ahrefs-free-website-stats-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"domains":["apify.com","stripe.com"],"maxItems":2}'
```

### Use with AI agents via MCP

Ahrefs Free Website Stats Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

For Claude Desktop, Cursor, or VS Code, add this JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

Your assistant can then call `automation-lab/ahrefs-free-website-stats-scraper`.

Example prompts:

- "Use automation-lab/ahrefs-free-website-stats-scraper to scrape AhrefsTop stats for these competitor domains and summarize the strongest domains."
- "Monitor this prospect list and identify domains with high traffic and strong DR."
- "Compare traffic countries for these SaaS competitors."

### Legality and ethical notes

This actor extracts publicly available page data.

You are responsible for using the output lawfully and respecting applicable terms, privacy rules, and rate limits.

Do not use the data for spam, deception, or abusive automation.

### FAQ

**Why are some fields null?**

AhrefsTop exposes different data on different pages. Locked or unavailable metrics are returned as `null`.

**Why did a domain fail?**

The public stats page may not exist for the domain, or the target may return a temporary error. Check the run log for HTTP status codes.

**Should I enable proxy?**

Leave proxy disabled first. Enable Apify Proxy only if your environment receives blocking or repeated network errors.

**How fast is the scraper?**

HTTP-only scraping is fast. A 100-domain cloud run typically finishes in under one minute with moderate concurrency.

**How is this different from private Ahrefs API access?**

This actor extracts public AhrefsTop page data. It does not access private Ahrefs account data or paid-only API features.

### Related scrapers

- [Semrush Free Website Stats Scraper](https://apify.com/automation-lab/semrush-free-website-stats-scraper)
- [SpyFu Scraper](https://apify.com/automation-lab/spyfu-scraper)
- [Similarweb Scraper](https://apify.com/automation-lab/similarweb-scraper)

### Limitations

The actor works with public AhrefsTop pages, not private Ahrefs account data.

It does not bypass paid Ahrefs features.

Large batches should use moderate concurrency.

### Changelog

Initial version extracts public domain stats, country data, keyword rows, competitor rows, and backlink profile signals.

### Support

If a run fails, share the run URL and the input domains so the issue can be reproduced.

# Actor input Schema

## `domains` (type: `array`):

Enter domains, hostnames, or Ahrefs/AhrefsTop website stats URLs. Examples: apify.com, https://ahrefs.com/websites/stripe.com, https://ahrefstop.com/websites/shopify.com

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

Safety cap for the number of input domains processed in this run.

## `maxConcurrency` (type: `integer`):

How many domains to request at the same time. Keep this modest to avoid target throttling.

## `includeRawHtml` (type: `boolean`):

Store the full page HTML in each dataset item for debugging. Leave off for normal runs to keep exports small.

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

Optional Apify proxy settings. Datacenter/automatic proxy is usually sufficient; use residential only if the target blocks your runs.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "stripe.com",
    "shopify.com"
  ],
  "maxItems": 10,
  "maxConcurrency": 5,
  "includeRawHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "domains": [
        "apify.com",
        "stripe.com",
        "shopify.com"
    ],
    "maxItems": 10,
    "maxConcurrency": 5,
    "includeRawHtml": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ahrefs-free-website-stats-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 = {
    "domains": [
        "apify.com",
        "stripe.com",
        "shopify.com",
    ],
    "maxItems": 10,
    "maxConcurrency": 5,
    "includeRawHtml": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ahrefs-free-website-stats-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 '{
  "domains": [
    "apify.com",
    "stripe.com",
    "shopify.com"
  ],
  "maxItems": 10,
  "maxConcurrency": 5,
  "includeRawHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/ahrefs-free-website-stats-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ahrefs Free Website Stats Scraper",
        "description": "Scrape public AhrefsTop domain stats: traffic, Domain Rating, backlinks, countries, keywords, and competitors for SEO monitoring.",
        "version": "0.1",
        "x-build-id": "gKdtbsS3IH8SMEzup"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ahrefs-free-website-stats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ahrefs-free-website-stats-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~ahrefs-free-website-stats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ahrefs-free-website-stats-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~ahrefs-free-website-stats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ahrefs-free-website-stats-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains or website stats URLs",
                        "type": "array",
                        "description": "Enter domains, hostnames, or Ahrefs/AhrefsTop website stats URLs. Examples: apify.com, https://ahrefs.com/websites/stripe.com, https://ahrefstop.com/websites/shopify.com",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum domains to process",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety cap for the number of input domains processed in this run.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many domains to request at the same time. Keep this modest to avoid target throttling.",
                        "default": 5
                    },
                    "includeRawHtml": {
                        "title": "Include raw HTML",
                        "type": "boolean",
                        "description": "Store the full page HTML in each dataset item for debugging. Leave off for normal runs to keep exports small.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Datacenter/automatic proxy is usually sufficient; use residential only if the target blocks your runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```