# Sedo Domain Auctions Scraper (`automation-lab/sedo-domain-auctions-scraper`) Actor

Extract Sedo expiring domain auction listings with reserve price, traffic, TLD, and deadline filters.

- **URL**: https://apify.com/automation-lab/sedo-domain-auctions-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

## Sedo Domain Auctions Scraper

Extract Sedo expiring domain auction listings from the public export CSV and turn them into clean Apify dataset records.

Use this actor to monitor domain names, TLDs, reserve prices, traffic values, and auction deadlines without downloading and cleaning Sedo spreadsheets manually.

### What does Sedo Domain Auctions Scraper do?

Sedo Domain Auctions Scraper fetches Sedo's expiring domain auctions export and saves one dataset item per domain.

It parses the UTF-16 semicolon CSV, normalizes booleans and numbers, and adds a `fetchedAt` timestamp for monitoring.

You can filter by TLD, reserve price, traffic, IDN status, hyphenated names, numeric names, and auction end date.

### Who is it for?

Domain investors use it to find expiring names that match their acquisition rules.

SEO teams use it to watch domains with traffic before auction deadlines.

Domain brokers use it to prepare shortlists for buyers.

Startup acquisition teams use it to monitor brandable names by TLD and price.

Analysts use it to export Sedo auction data into spreadsheets, dashboards, and alerts.

### Why use it?

🧭 Avoid opening the Sedo CSV manually every day.

💰 Filter out domains that exceed your reserve-price budget.

🌐 Focus on exact TLDs such as `.com`, `.net`, `.org`, `.io`, or country-code domains.

📈 Keep traffic-bearing domains in a structured dataset.

⏰ Monitor auction deadlines with scheduled Apify runs.

### Data table

| Field | Description |
| --- | --- |
| `domain` | Domain name listed on Sedo |
| `tld` | Normalized top-level domain |
| `detailUrl` | Sedo details page URL |
| `startTime` | Auction start timestamp from Sedo |
| `endTime` | Auction end timestamp from Sedo |
| `reservePriceUsd` | Numeric reserve price from the export |
| `traffic` | Sedo traffic value |
| `domainLength` | Domain length from the export |
| `isIdn` | Whether the domain is an IDN |
| `hasHyphen` | Whether the name contains a hyphen |
| `hasNumbers` | Whether the name contains numbers |
| `fetchedAt` | Actor fetch timestamp |

### How much does it cost to scrape Sedo domain auctions?

The actor uses pay-per-event pricing: a `$0.005` run start event plus `$0.000026595` for each domain auction record saved to the dataset.

| Example run size | Estimated actor charge |
| --- | ---: |
| 20 domains (default prefill) | about 0.0055 USD |
| 100 domains | about 0.0077 USD |
| 1,000 domains | about 0.0316 USD |
| 10,000 domains | about 0.2710 USD |

Use `maxItems` and filters to keep test runs small. With 5 USD of Apify free-plan credits, the default 20-domain sample can be run roughly 900 times, or you can collect about 185,000 records in larger batches before platform usage costs.

### How to run it

1. Open the actor on Apify.
2. Keep the default filters for a quick sample.
3. Add TLDs you care about, such as `com`, `net`, or `io`.
4. Set `maxReservePrice` for your budget.
5. Set `minTraffic` if you only want domains with traffic.
6. Click **Start**.
7. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

#### `maxItems`

Maximum number of domain auction records to save after filters.

#### `tlds`

Optional list of TLDs. Use values without dots, for example `com` rather than `.com`.

#### `maxReservePrice`

Only include domains with a reserve price at or below this value.

#### `minTraffic`

Only include domains with at least this Sedo traffic value.

#### `includeIdn`

Turn off to exclude IDN domains.

#### `includeHyphenated`

Turn off to exclude hyphenated domain names.

#### `includeNumeric`

Turn off to exclude domains containing numbers.

#### `onlyEndingBefore`

Optional ISO date/time cutoff for deadline-driven monitoring.

#### `csvUrl`

Advanced override for the Sedo export URL.

### Example input

```json
{
  "maxItems": 100,
  "tlds": ["com", "net", "org"],
  "maxReservePrice": 500,
  "minTraffic": 0,
  "includeIdn": true,
  "includeHyphenated": true,
  "includeNumeric": true
}
````

### Example output

```json
{
  "domain": "exampledomain.com",
  "tld": "com",
  "detailUrl": "https://sedo.com/search/details/?domain=exampledomain.com&origin=export",
  "startTime": "2026-07-08 18:00:00",
  "endTime": "2026-07-15 18:00:00",
  "reservePriceUsd": 79,
  "traffic": 3,
  "domainLength": 13,
  "isIdn": false,
  "hasHyphen": false,
  "hasNumbers": false,
  "fetchedAt": "2026-07-09T00:00:00.000Z"
}
```

### Tips for domain investors

Start broad, then tighten filters.

Use low `maxItems` values while testing.

Schedule daily runs to detect changes in the expiring auction list.

Export CSV to sort by traffic, reserve price, or deadline.

Combine TLD filters with reserve-price filters for acquisition shortlists.

### Integrations

Send new Sedo auction domains to Google Sheets.

Trigger Slack alerts when high-traffic domains appear.

Store historical snapshots in an Apify dataset.

Connect results to Make, Zapier, or custom API workflows.

Use webhooks to notify brokers before auctions end.

### 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/sedo-domain-auctions-scraper').call({
  maxItems: 100,
  tlds: ['com', 'net'],
  maxReservePrice: 500
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/sedo-domain-auctions-scraper').call(run_input={
    'maxItems': 100,
    'tlds': ['com', 'net'],
    'maxReservePrice': 500,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sedo-domain-auctions-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"tlds":["com","net"],"maxReservePrice":500}'
```

### MCP usage

Use Apify MCP with Claude Code or Claude Desktop to run the actor from natural language.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/sedo-domain-auctions-scraper`

Claude Code command:

```bash
claude mcp add apify-sedo-domain-auctions --transport http https://mcp.apify.com/?tools=automation-lab/sedo-domain-auctions-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-sedo-domain-auctions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sedo-domain-auctions-scraper"
    }
  }
}
```

Example prompts:

- "Run the Sedo domain auctions scraper for .com names under 500 reserve."
- "Find Sedo expiring auctions with traffic and export them to CSV."
- "Monitor Sedo .net auction names ending this week."

### Scheduling workflows

Create a daily schedule in Apify.

Set `maxItems` high enough for your watchlist.

Use webhooks or integrations to compare each new dataset with the previous run.

This is useful for repeat monitoring of expiring domain auctions.

### Quality notes

The actor reads Sedo's public export.

It does not log in to Sedo.

It does not place bids.

It does not scrape private account pages.

It does not crawl every detail page by default.

### Troubleshooting

If the run returns fewer items than expected, check your TLD, price, and traffic filters.

If no items are returned, remove filters and run again with a small `maxItems` value.

If Sedo changes the export URL, the actor attempts HTML discovery and also supports a custom `csvUrl` override.

### Legality

This actor extracts publicly reachable auction export data.

You are responsible for using results according to Sedo's terms, applicable laws, and your internal compliance requirements.

Do not use the actor for spam, abuse, or unauthorized bidding automation.

### Related scrapers

Other automation-lab actors can support domain and SEO workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/bulk-url-status-checker
- https://apify.com/automation-lab/domain-availability-checker

### FAQ

#### Does it require a Sedo account?

No. The actor uses the public expiring auctions export.

#### Does it bid on domains?

No. It only extracts auction listing data.

#### Can I monitor only .com domains?

Yes. Set `tlds` to `["com"]`.

#### Can I exclude hyphenated domains?

Yes. Set `includeHyphenated` to `false`.

#### Can I export to Excel?

Yes. Apify datasets can be exported as Excel, CSV, JSON, XML, RSS, and HTML.

#### Why is reserve price named `reservePriceUsd`?

The Sedo export provides a numeric reserve price. The actor stores it as a number for sorting and filtering.

### Changelog

Initial version extracts Sedo expiring domain auction CSV rows with typed fields and filters.

# Actor input Schema

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

Maximum number of Sedo auction records to save after filters are applied.

## `tlds` (type: `array`):

Optional list of TLDs to include, such as com, net, io, or de. Leave empty for all TLDs.

## `maxReservePrice` (type: `integer`):

Only include auctions with a reserve price at or below this value. Leave empty to include all reserves.

## `minTraffic` (type: `integer`):

Only include Sedo domains with at least this traffic value. Leave empty to include all traffic levels.

## `includeIdn` (type: `boolean`):

Turn off to exclude internationalized domain names.

## `includeHyphenated` (type: `boolean`):

Turn off to exclude domains containing hyphens.

## `includeNumeric` (type: `boolean`):

Turn off to exclude domains containing numeric characters.

## `onlyEndingBefore` (type: `string`):

Optional ISO date/time cutoff. Example: 2026-07-31T23:59:59Z.

## `csvUrl` (type: `string`):

Advanced override for the Sedo export URL. Leave empty to use the current public expiring auctions CSV and HTML discovery fallback.

## Actor input object example

```json
{
  "maxItems": 20,
  "tlds": [
    "com",
    "net",
    "org"
  ],
  "includeIdn": true,
  "includeHyphenated": true,
  "includeNumeric": 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 = {
    "maxItems": 20,
    "tlds": [
        "com",
        "net",
        "org"
    ],
    "minTraffic": 0,
    "includeIdn": true,
    "includeHyphenated": true,
    "includeNumeric": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sedo-domain-auctions-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 20,
    "tlds": [
        "com",
        "net",
        "org",
    ],
    "minTraffic": 0,
    "includeIdn": True,
    "includeHyphenated": True,
    "includeNumeric": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sedo-domain-auctions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "tlds": [
    "com",
    "net",
    "org"
  ],
  "minTraffic": 0,
  "includeIdn": true,
  "includeHyphenated": true,
  "includeNumeric": true
}' |
apify call automation-lab/sedo-domain-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sedo Domain Auctions Scraper",
        "description": "Extract Sedo expiring domain auction listings with reserve price, traffic, TLD, and deadline filters.",
        "version": "0.1",
        "x-build-id": "sk5NcrCXJZFMTltAc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sedo-domain-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sedo-domain-auctions-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~sedo-domain-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sedo-domain-auctions-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~sedo-domain-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sedo-domain-auctions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Maximum domains",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of Sedo auction records to save after filters are applied.",
                        "default": 20
                    },
                    "tlds": {
                        "title": "TLDs",
                        "type": "array",
                        "description": "Optional list of TLDs to include, such as com, net, io, or de. Leave empty for all TLDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReservePrice": {
                        "title": "Maximum reserve price (USD/EUR display value)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include auctions with a reserve price at or below this value. Leave empty to include all reserves."
                    },
                    "minTraffic": {
                        "title": "Minimum traffic",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include Sedo domains with at least this traffic value. Leave empty to include all traffic levels."
                    },
                    "includeIdn": {
                        "title": "Include IDN domains",
                        "type": "boolean",
                        "description": "Turn off to exclude internationalized domain names.",
                        "default": true
                    },
                    "includeHyphenated": {
                        "title": "Include hyphenated domains",
                        "type": "boolean",
                        "description": "Turn off to exclude domains containing hyphens.",
                        "default": true
                    },
                    "includeNumeric": {
                        "title": "Include domains with numbers",
                        "type": "boolean",
                        "description": "Turn off to exclude domains containing numeric characters.",
                        "default": true
                    },
                    "onlyEndingBefore": {
                        "title": "Only auctions ending before",
                        "type": "string",
                        "description": "Optional ISO date/time cutoff. Example: 2026-07-31T23:59:59Z."
                    },
                    "csvUrl": {
                        "title": "Custom Sedo CSV URL",
                        "type": "string",
                        "description": "Advanced override for the Sedo export URL. Leave empty to use the current public expiring auctions CSV and HTML discovery fallback."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```