# Danish SMB Website Lead-Flow Auditor (`pixelforge_agency/danish-smb-lead-flow-auditor`) Actor

Batch-audit Danish SMB websites for missed leads: contact flow, CTA clarity, trust signals, mobile basics, and SEO quick wins.

- **URL**: https://apify.com/pixelforge\_agency/danish-smb-lead-flow-auditor.md
- **Developed by:** [Christian Cesar](https://apify.com/pixelforge_agency) (community)
- **Categories:** SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Danish SMB Website Lead-Flow Auditor

Find missed leads on Danish local business websites — contact flow, CTA, trust signals, mobile basics and SEO quick wins in one automated report.

### What this Actor does

**Danish SMB Website Lead-Flow Auditor** helps agencies, freelancers and small-business operators quickly assess whether a public website makes it easy for visitors to contact, book or request an offer.

The Actor takes either one public website URL or a batch of URLs and returns practical audits with:

- a **Lead-Flow Score** from 0–100 per site,
- sub-scores for contact flow, CTA, trust, mobile/technical and SEO basics,
- prioritized findings with severity,
- score-band-specific quick wins,
- a client-friendly Markdown report per result,
- a batch summary with average score and lowest-score opportunities,
- structured JSON output for workflows, dashboards or follow-up services.

It is designed especially for Danish local service businesses such as salons, clinics, restaurants, tradespeople, advisors, shops and other SMBs where the website’s main job is to create calls, bookings or inquiries.

### Who it is for

Use it if you are:

- an agency that wants a fast website audit lead magnet,
- a freelancer selling website/SEO/conversion audits,
- a local SMB owner who wants to find obvious lead-flow problems,
- an automation builder who needs structured website audit output,
- a consultant preparing before/after recommendations for a client.

### Typical use cases

- A salon wants to understand why visitors do not book appointments.
- A clinic wants more online inquiries from mobile visitors.
- A restaurant wants to check whether booking/contact actions are clear.
- A tradesperson wants to make phone/contact options easier to find.
- An agency wants to scan prospects and create practical audit reports.
- A freelancer wants a repeatable audit-as-a-service workflow.

### What is checked

The MVP checks the public homepage for practical lead-flow signals:

| Area | What it looks for |
|---|---|
| Contact flow | phone links, email links, visible phone patterns, forms, booking signals, social links |
| CTA clarity | action words such as contact, book, call, get offer, reserve, request demo |
| Trust | HTTPS, reviews, address/CVR signals, social proof, about/company signals |
| Mobile/technical basics | viewport, title, meta description, language attribute, page size |
| SEO basics | title, meta description, H1/H2 structure and basic category relevance |

### Input

Single-site mode:

```json
{
  "url": "https://www.example.dk",
  "businessName": "Example ApS",
  "businessCategory": "Frisør / beauty",
  "language": "da",
  "includeMarkdown": true
}
````

Batch mode:

```json
{
  "urls": [
    {"url": "https://www.salon39.dk", "businessName": "Salon39 sample", "businessCategory": "Frisør"},
    {"url": "https://www.tandcity.dk", "businessName": "TandCity sample", "businessCategory": "Tandlæge"},
    {"url": "https://www.restaurantkronborg.dk", "businessName": "Restaurant Kronborg sample", "businessCategory": "Restaurant"}
  ],
  "maxUrls": 25,
  "language": "da",
  "includeMarkdown": true
}
```

#### Input fields

| Field | Required | Description |
|---|---:|---|
| `url` | no | Public website URL for one-site mode |
| `urls` | no | Batch mode list; accepts strings or objects with `url`, `businessName`, `businessCategory` |
| `businessName` | no | Default company/brand name when item does not provide one |
| `businessCategory` | no | Default category such as restaurant, clinic, salon, tradesperson |
| `maxUrls` | no | Safety cap for batch mode, 1–100; default 25 |
| `language` | no | MVP primarily supports `da`; `en` reserved for later |
| `includeMarkdown` | no | Whether to include client-friendly Markdown reports |

Provide either `url` or `urls`.

### Output

The Actor includes Apify output and dataset schemas for cleaner Store/API/agent integration.

The Actor writes one dataset item per audited URL plus key-value records:

- `OUTPUT` — batch summary JSON with all results,
- `REPORT.md` — client-friendly batch Markdown summary,
- default dataset items — one structured audit result per URL, each with optional Markdown included.

Example output shape:

```json
{
  "status": "ok",
  "mode": "batch",
  "requestedCount": 3,
  "succeededCount": 3,
  "failedCount": 0,
  "averageScore": 64.0,
  "lowestScoreSites": [
    {"url": "https://www.salon39.dk", "score": 23, "scoreBand": "critical"}
  ],
  "results": [
    {
      "url": "https://www.example.dk",
      "finalUrl": "https://www.example.dk/",
      "businessName": "Example ApS",
      "businessCategory": "Frisør / beauty",
      "status": "SUCCEEDED",
      "scores": {
        "overall": 72,
        "contactFlow": 65,
        "cta": 80,
        "trust": 70,
        "mobileTechnical": 100,
        "seoBasics": 80
      },
      "scoreBand": "good_with_optimizations",
      "findings": [],
      "quickWins": [],
      "markdownReport": "# Website Lead-Flow Audit ..."
    }
  ]
}
```

### Score bands

| Band | Score | Meaning |
|---|---:|---|
| `critical` | 0–39 | The site likely needs urgent contact/CTA/trust fixes |
| `needs_improvement` | 40–69 | Useful foundation, but clear conversion issues remain |
| `good_with_optimizations` | 70–85 | Solid site; focus on tracking, CTA refinement and trust placement |
| `strong` | 86–100 | Strong baseline; focus on measurement and small conversion lifts |

### Sample verified cloud run

The Actor has been built and tested in Apify Cloud.

- Actor ID: `cxvutXzwuLieoPHF9`
- Latest verified build: `0.1.4`
- Sample test site: `https://www.restaurantkronborg.dk`
- Result: `89/100`, score band `strong`
- Dataset items: `1`

### Suggested pricing model later

This is only a draft for later monetization review. Pricing/publication must be approved separately.

| Option | Draft idea |
|---|---|
| Free demo | 1 URL with limited output |
| Pay-per-event | Per audited URL plus Apify platform costs |
| Agency tier later | Batch audits, exports, prospect workflow and optional human review |

### Limitations

- Audits public website pages only.
- No login.
- No private data extraction.
- No forms are submitted.
- No automatic outreach.
- Heuristic audit; review before using as paid client delivery.
- Does not guarantee more leads, sales, rankings or revenue.
- Some JavaScript-heavy websites may expose fewer signals to the MVP than a browser-rendered audit would.

### Safety and compliance

This Actor is built for low-risk public website diagnostics:

- It reads public pages only.
- It does not bypass access controls.
- It does not send emails, forms, messages or proposals.
- Any client-facing outreach or paid delivery should be manually approved.

### Local run

```bash
mkdir -p storage/key_value_stores/default storage/datasets/default
cat > storage/key_value_stores/default/INPUT.json <<'JSON'
{
  "url": "https://www.restaurantkronborg.dk",
  "businessName": "Restaurant Kronborg sample",
  "businessCategory": "Restaurant",
  "includeMarkdown": true
}
JSON
python -m src.main
```

Outputs:

- `storage/key_value_stores/default/OUTPUT.json`
- `storage/key_value_stores/default/REPORT.md`
- `storage/datasets/default/000000001.json`

### Best next improvements

Planned improvements before serious public monetization:

1. Browser-rendered checks for JavaScript-heavy sites.
2. Batch input for multiple URLs.
3. PDF export.
4. More Danish industry-specific heuristics.
5. Optional human review workflow.
6. Better local SEO checks.
7. Separate agency/prospecting mode.

# Actor input Schema

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

Public website URL to audit. Use this for one-site mode. For batch mode, use urls instead.

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

Optional batch mode. Add multiple public website URLs, either as plain strings or objects with url, businessName, and businessCategory.

## `businessName` (type: `string`):

Optional default company or brand name used when a URL item does not provide its own businessName.

## `businessCategory` (type: `string`):

Optional default category such as Frisør, Restaurant, Klinik, Håndværker.

## `maxUrls` (type: `integer`):

Safety cap for batch mode. MVP cap is 1–100.

## `language` (type: `string`):

Report language. MVP primarily supports Danish.

## `includeMarkdown` (type: `boolean`):

Include client-friendly Markdown reports in each result and a batch summary report.

## Actor input object example

```json
{
  "url": "https://www.example.dk",
  "urls": [
    {
      "url": "https://www.salon39.dk",
      "businessName": "Salon39 sample",
      "businessCategory": "Frisør"
    },
    {
      "url": "https://www.tandcity.dk",
      "businessName": "TandCity sample",
      "businessCategory": "Tandlæge"
    },
    {
      "url": "https://www.restaurantkronborg.dk",
      "businessName": "Restaurant Kronborg sample",
      "businessCategory": "Restaurant"
    }
  ],
  "businessName": "Example ApS",
  "businessCategory": "Lokal servicevirksomhed",
  "maxUrls": 25,
  "language": "da",
  "includeMarkdown": true
}
```

# Actor output Schema

## `auditResults` (type: `string`):

One structured audit item per URL.

## `summaryJson` (type: `string`):

Run-level summary with counts, average score, lowest-score sites, and embedded results.

## `summaryReport` (type: `string`):

Client-friendly batch summary report.

# 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 = {
    "url": "https://www.example.dk",
    "urls": [
        {
            "url": "https://www.salon39.dk",
            "businessName": "Salon39 sample",
            "businessCategory": "Frisør"
        },
        {
            "url": "https://www.tandcity.dk",
            "businessName": "TandCity sample",
            "businessCategory": "Tandlæge"
        },
        {
            "url": "https://www.restaurantkronborg.dk",
            "businessName": "Restaurant Kronborg sample",
            "businessCategory": "Restaurant"
        }
    ],
    "businessName": "Example ApS",
    "businessCategory": "Lokal servicevirksomhed"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pixelforge_agency/danish-smb-lead-flow-auditor").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 = {
    "url": "https://www.example.dk",
    "urls": [
        {
            "url": "https://www.salon39.dk",
            "businessName": "Salon39 sample",
            "businessCategory": "Frisør",
        },
        {
            "url": "https://www.tandcity.dk",
            "businessName": "TandCity sample",
            "businessCategory": "Tandlæge",
        },
        {
            "url": "https://www.restaurantkronborg.dk",
            "businessName": "Restaurant Kronborg sample",
            "businessCategory": "Restaurant",
        },
    ],
    "businessName": "Example ApS",
    "businessCategory": "Lokal servicevirksomhed",
}

# Run the Actor and wait for it to finish
run = client.actor("pixelforge_agency/danish-smb-lead-flow-auditor").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 '{
  "url": "https://www.example.dk",
  "urls": [
    {
      "url": "https://www.salon39.dk",
      "businessName": "Salon39 sample",
      "businessCategory": "Frisør"
    },
    {
      "url": "https://www.tandcity.dk",
      "businessName": "TandCity sample",
      "businessCategory": "Tandlæge"
    },
    {
      "url": "https://www.restaurantkronborg.dk",
      "businessName": "Restaurant Kronborg sample",
      "businessCategory": "Restaurant"
    }
  ],
  "businessName": "Example ApS",
  "businessCategory": "Lokal servicevirksomhed"
}' |
apify call pixelforge_agency/danish-smb-lead-flow-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pixelforge_agency/danish-smb-lead-flow-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Danish SMB Website Lead-Flow Auditor",
        "description": "Batch-audit Danish SMB websites for missed leads: contact flow, CTA clarity, trust signals, mobile basics, and SEO quick wins.",
        "version": "0.1",
        "x-build-id": "xNgqRdnYXjkz9ae4y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pixelforge_agency~danish-smb-lead-flow-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pixelforge_agency-danish-smb-lead-flow-auditor",
                "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/pixelforge_agency~danish-smb-lead-flow-auditor/runs": {
            "post": {
                "operationId": "runs-sync-pixelforge_agency-danish-smb-lead-flow-auditor",
                "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/pixelforge_agency~danish-smb-lead-flow-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-pixelforge_agency-danish-smb-lead-flow-auditor",
                "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": {
                    "url": {
                        "title": "Single website URL",
                        "type": "string",
                        "description": "Public website URL to audit. Use this for one-site mode. For batch mode, use urls instead."
                    },
                    "urls": {
                        "title": "Batch website URLs",
                        "type": "array",
                        "description": "Optional batch mode. Add multiple public website URLs, either as plain strings or objects with url, businessName, and businessCategory."
                    },
                    "businessName": {
                        "title": "Default business name",
                        "type": "string",
                        "description": "Optional default company or brand name used when a URL item does not provide its own businessName."
                    },
                    "businessCategory": {
                        "title": "Default business category",
                        "type": "string",
                        "description": "Optional default category such as Frisør, Restaurant, Klinik, Håndværker."
                    },
                    "maxUrls": {
                        "title": "Max URLs",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for batch mode. MVP cap is 1–100.",
                        "default": 25
                    },
                    "language": {
                        "title": "Report language",
                        "enum": [
                            "da",
                            "en"
                        ],
                        "type": "string",
                        "description": "Report language. MVP primarily supports Danish.",
                        "default": "da"
                    },
                    "includeMarkdown": {
                        "title": "Include Markdown reports",
                        "type": "boolean",
                        "description": "Include client-friendly Markdown reports in each result and a batch summary report.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
