# Austria WKO Business Directory Scraper (`automation-lab/austria-wko-business-directory-scraper`) Actor

Extract Austrian business leads from WKO Firmen A-Z by keyword and location. Get addresses, phones, emails, websites, and profile URLs as CSV or JSON.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Austria WKO Business Directory Scraper

Extract Austrian company leads from the official WKO Firmen A-Z business directory.

Use this actor to search by industry, service, product, or company keyword and a location such as Wien, Graz, Linz, Salzburg, or an Austrian district. It returns structured business records with company names, addresses, phone numbers, emails, websites, WKO profile URLs, and search context.

### What does Austria WKO Business Directory Scraper do?

Austria WKO Business Directory Scraper converts public WKO Firmen A-Z search results into a clean dataset.

It can:

- 🔎 Search WKO Firmen A-Z by keyword and location
- 🏢 Extract Austrian company and branch/location records
- 📍 Capture street, postal code, city, and full address text
- ☎️ Save phone and mobile phone links when WKO exposes them
- ✉️ Save emails and websites when they are visible on WKO pages
- 🔗 Preserve WKO profile URLs for verification and deduplication
- 📄 Optionally visit detail pages for extra text enrichment

### Who is it for?

This scraper is useful for several workflows:

- 🧑‍💼 B2B sales teams building Austrian lead lists
- 🧭 Local SEO agencies mapping businesses by city and industry
- 📊 Market researchers measuring industry presence by region
- 🧾 Compliance and vendor-enrichment teams checking public company listings
- 🏘️ Franchise, real estate, and field-service teams researching local providers
- 🧑‍💻 Data teams that need repeatable WKO directory exports through API calls

### Why use this actor?

Manual WKO searches are fine for one company, but they do not scale. This actor gives you repeatable exports with the same fields each time.

Key benefits:

- No browser setup required
- Server-rendered WKO result pages are scraped with lightweight HTTP requests
- Output is ready for CSV, Excel, Google Sheets, CRMs, and enrichment tools
- Search context is included on every row so datasets remain auditable
- Optional detail-page mode lets you trade speed for richer profile text

### Data extracted

| Field | Description |
| --- | --- |
| `companyName` | Name of the WKO business/location record |
| `subtitle` | Listing subtitle or description when available |
| `street` | Street address |
| `postalCode` | Austrian postal code parsed from the address |
| `city` | City/locality parsed from the address |
| `address` | Full visible address text |
| `phone` | First phone number exposed on the listing |
| `mobilePhone` | Second/mobile phone number when exposed |
| `email` | Email address when exposed |
| `website` | Website URL when exposed |
| `profileUrl` | WKO profile/detail URL |
| `sourceUrl` | WKO result page where the record was found |
| `searchKeyword` | Input keyword used for the search |
| `searchLocation` | Input location used for the search |
| `pageNumber` | Result page number |
| `detailFetched` | Whether a detail page was fetched |
| `detailText` | Optional text from the detail page |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Austria WKO business leads?

This actor uses pay-per-event pricing.

You pay a small run start fee plus a per-business-record fee. The exact live prices are shown on the Apify actor page before you run it.

Cost control tips:

- Start with a small `maxItems` value
- Keep `detailPages` disabled for the cheapest broad lead lists
- Enable `detailPages` only when you need profile text or extra contact enrichment
- Use specific keywords and locations to avoid irrelevant exports

### How to use

1. Open the actor on Apify.
2. Enter a WKO keyword, for example `Tischler`, `Marketing`, `Installateur`, or `Steuerberater`.
3. Enter a location, for example `Wien`, `Graz`, `Linz`, or `Salzburg`.
4. Set `maxItems`.
5. Decide whether to fetch detail pages.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input example

```json
{
  "keyword": "Tischler",
  "location": "Wien",
  "maxItems": 100,
  "detailPages": false,
  "requestDelayMillis": 250
}
````

### Input fields

#### `keyword`

The WKO search term. Use an industry, service, product, or company keyword.

Examples:

- `Tischler`
- `Marketing`
- `Installateur`
- `Steuerberater`
- `Bäckerei`

#### `location`

The Austrian location to search.

Examples:

- `Wien`
- `Graz`
- `Linz`
- `Salzburg`
- `Innsbruck`

#### `maxItems`

Maximum number of business records to save.

#### `detailPages`

When enabled, the actor opens each WKO profile URL and saves additional detail text when available. This is slower and uses more requests.

#### `requestDelayMillis`

Delay between HTTP requests. Increase it for large runs or conservative crawling.

### Output example

```json
{
  "companyName": "DOMINKOVIC Ges.m.b.H.",
  "subtitle": "Holzfussböden & Tischlerarbeiten",
  "street": "Wallagasse 4",
  "postalCode": "1110",
  "city": "Wien",
  "address": "Wallagasse 4, 1110 Wien",
  "phone": "+43 1 8908986",
  "email": "office@example.at",
  "website": "https://www.example.at/",
  "profileUrl": "https://firmen.wko.at/...",
  "sourceUrl": "https://firmen.wko.at/tischler/wien",
  "searchKeyword": "Tischler",
  "searchLocation": "Wien",
  "pageNumber": 1,
  "detailFetched": false,
  "scrapedAt": "2026-06-27T03:31:20.913Z"
}
```

### Tips for better WKO scraping results

- Use German-language industry terms because WKO is an Austrian directory.
- Try both broad and narrow terms, for example `Marketing` and `Online Marketing`.
- Use the official Austrian city or district name.
- Run one city at a time for cleaner regional segmentation.
- Deduplicate by `profileUrl` when combining multiple searches.
- Keep `sourceUrl`, `searchKeyword`, and `searchLocation` in downstream databases.

### Common workflows

#### Austrian B2B lead generation

Search for a target industry in each city and export records to your CRM.

#### Local SEO prospecting

Find local companies that expose websites or missing websites in WKO results.

#### Market mapping

Count companies by keyword and location to compare regional density.

#### Vendor enrichment

Match your vendor list against WKO profile URLs and public contact details.

### Integrations

You can connect the dataset to:

- Google Sheets through Apify integrations
- Make or Zapier automations
- CRM enrichment pipelines
- BI dashboards
- Data warehouses
- Custom Node.js or Python jobs through the Apify API

### 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/austria-wko-business-directory-scraper').call({
  keyword: 'Tischler',
  location: 'Wien',
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/austria-wko-business-directory-scraper').call(run_input={
    'keyword': 'Marketing',
    'location': 'Graz',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~austria-wko-business-directory-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"Tischler","location":"Wien","maxItems":100}'
```

### Use with AI agents via MCP

Austria WKO Business Directory Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one.

**Setup for Claude Code**

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

**Setup for Claude Desktop, Cursor, or VS Code**

Add this to your MCP config file:

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

Your AI assistant will authenticate with your Apify account on first use.

Example prompts:

- "Use automation-lab/austria-wko-business-directory-scraper to find 100 Tischler businesses in Wien and summarize which have websites."
- "Extract WKO marketing companies in Graz and prepare a CSV for sales outreach."
- "Run an Austrian business directory search for Installateur in Linz and list phone numbers."

### Legality and responsible use

This actor extracts publicly accessible information from WKO Firmen A-Z pages. You are responsible for using the data lawfully and respecting privacy, data protection, and marketing rules such as GDPR and Austrian communications laws.

Recommended practices:

- Use the data for legitimate business purposes
- Avoid spam or unsolicited bulk outreach
- Keep records accurate and up to date
- Honor deletion or opt-out requests where applicable
- Review WKO terms and your legal obligations before production use

### FAQ

**How fast is the WKO business directory scraper?**

Typical HTTP-only runs finish quickly: small searches complete in seconds, while 100-result WKO searches usually finish in about one to two minutes.

**How much does the actor cost?**

The actor uses pay-per-event pricing. You pay a small start fee plus a low per-business-record charge shown on the Apify actor page.

**Is there an official WKO API?**

This actor is designed for users who need structured exports from public WKO Firmen A-Z pages without building their own crawler.

**Why did I get fewer records than `maxItems`?**

WKO may have fewer matching results for your keyword/location combination. Try a broader keyword or a larger nearby location.

**Why are some emails or websites missing?**

WKO does not expose every contact field for every business. The actor only saves fields that are visible in the public listing or detail page.

### Troubleshooting

**Why is detail-page mode slower?**

Detail mode makes one extra request per business profile. Use it only when you need additional detail text or enrichment.

### Related scrapers

Other automation-lab actors that can complement WKO lead generation:

- https://apify.com/automation-lab/google-maps-business-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/company-enrichment-scraper

### Limits

The actor depends on the current public WKO page structure. If WKO changes its HTML, selectors may need maintenance. Large runs should use a polite delay and focused inputs.

### Changelog

#### 0.1

Initial version with HTTP extraction from WKO search results, pagination, contact fields, address parsing, and optional detail-page enrichment.

### Support

If a run fails or a field looks wrong, share the run URL and input with support so the actor can be checked against the current WKO page structure.

# Actor input Schema

## `keyword` (type: `string`):

WKO search term such as an industry, service, product, or company keyword.

## `location` (type: `string`):

Austrian city, federal state, or district, for example Wien, Graz, Salzburg, or Linz.

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

Maximum number of WKO business records to save.

## `detailPages` (type: `boolean`):

Open each WKO profile page to enrich records with detail text and missing contact fields. Slower but richer.

## `requestDelayMillis` (type: `integer`):

Polite delay between WKO HTTP requests. Increase for large runs.

## Actor input object example

```json
{
  "keyword": "Tischler",
  "location": "Wien",
  "maxItems": 20,
  "detailPages": false,
  "requestDelayMillis": 250
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "Tischler",
    "location": "Wien",
    "maxItems": 20,
    "detailPages": false,
    "requestDelayMillis": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/austria-wko-business-directory-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 = {
    "keyword": "Tischler",
    "location": "Wien",
    "maxItems": 20,
    "detailPages": False,
    "requestDelayMillis": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/austria-wko-business-directory-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 '{
  "keyword": "Tischler",
  "location": "Wien",
  "maxItems": 20,
  "detailPages": false,
  "requestDelayMillis": 250
}' |
apify call automation-lab/austria-wko-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Austria WKO Business Directory Scraper",
        "description": "Extract Austrian business leads from WKO Firmen A-Z by keyword and location. Get addresses, phones, emails, websites, and profile URLs as CSV or JSON.",
        "version": "0.1",
        "x-build-id": "FEOA4z1I1xF3cCDtC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~austria-wko-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-austria-wko-business-directory-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~austria-wko-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-austria-wko-business-directory-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~austria-wko-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-austria-wko-business-directory-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": [
                    "keyword",
                    "location"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword / industry",
                        "type": "string",
                        "description": "WKO search term such as an industry, service, product, or company keyword.",
                        "default": "Tischler"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Austrian city, federal state, or district, for example Wien, Graz, Salzburg, or Linz.",
                        "default": "Wien"
                    },
                    "maxItems": {
                        "title": "Maximum businesses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of WKO business records to save.",
                        "default": 20
                    },
                    "detailPages": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each WKO profile page to enrich records with detail text and missing contact fields. Slower but richer.",
                        "default": false
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between WKO HTTP requests. Increase for large runs.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
