# Trouwen.nl Scraper — Dutch Wedding Venues & Vendors (`studio-amba/trouwen-scraper`) Actor

Scrape wedding venues and vendor listings from Trouwen.nl, the Dutch wedding directory (also covers Bruiloft.nl — same company). Extract names, addresses, phone, email, website, ratings, and descriptions by city and category. No login needed.

- **URL**: https://apify.com/studio-amba/trouwen-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Trouwen.nl Scraper — Dutch Wedding Venues & Vendors

Scrape wedding venue and vendor listings from [Trouwen.nl](https://trouwen.nl), the Dutch wedding directory (also covers Bruiloft.nl — same company, same dataset). Get names, addresses, phone, email, website, ratings, and descriptions by city and vendor category across the Netherlands.

### What is Trouwen.nl Scraper?

Trouwen.nl lists wedding venues and vendors across the Netherlands — trouwlocaties (venues), castles, hotels, restaurants, DJs, photographers, videographers, wedding planners, decorators, and more, organized by city and by category. Every vendor detail page carries `LocalBusiness`/`Organization` JSON-LD structured data, so this actor parses that directly (with HTML fallbacks where JSON-LD is thin).

This actor walks a city + category listing page, follows the site's own pagination, and extracts every vendor's contact and profile data from its detail page. What people build with it:

- **Wedding vendor market research** — wedding planners and vendors map venue density and vendor competition by Dutch city.
- **Lead generation** — B2B services selling to wedding venues (insurance, POS, event software, photography gear) build outreach lists filtered by city and category.
- **Venue sourcing tools** — wedding planning platforms build their own searchable venue databases without maintaining a directory from scratch.
- **Competitive intelligence** — venue owners benchmark their own listing (description, rating, review count) against competitors in the same city.

### What data does Trouwen.nl Scraper extract?

Each venue or vendor record includes:

- **Name** — the business name
- **Address** — street address, city, and Dutch postal code
- **Category** — the Trouwen.nl category the listing appears under (Trouwlocaties, Bruidssuite, Restaurants, DJ Bruiloft, etc.)
- **Description** — the vendor's own profile text
- **Phone** — direct contact number, where published
- **Email** — direct contact email, where published
- **Website** — the vendor's own external website
- **Rating and review count** — where the vendor has received on-platform reviews
- **Image** — the vendor's primary listing photo
- **URL** — the source detail page

### How to scrape trouwen.nl data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `city` | String | No | Dutch city or town, e.g. `"amsterdam"`, `"utrecht"`, `"rotterdam"`. Defaults to `"amsterdam"`. |
| `category` | String | No | Vendor category — venues, hotels, restaurants, photographers, DJs, planners, and 15 more. Defaults to `"trouwlocaties"`. |
| `startUrls` | Array | No | Specific Trouwen.nl category/city listing pages or vendor detail pages. Overrides city + category. |
| `maxResults` | Integer | No | Maximum venues/vendors to return (default: 100, max: 5,000) |
| `proxyConfiguration` | Object | No | Proxy settings. Not required — Trouwen.nl has no anti-bot protection — but recommended for large runs. |

**Tips:**

- Combine `city` and `category` for a focused pull, e.g. `city: "utrecht"`, `category: "trouwfotografie"` for wedding photographers in Utrecht.
- Pagination is handled automatically — the actor reads the site's own page count and only fetches as many pages as needed to reach `maxResults`.
- For a nationwide category database, run once per major Dutch city (Amsterdam, Rotterdam, Den Haag, Utrecht, Eindhoven...) with a high `maxResults`.
- Bruiloft.nl listings are the same underlying dataset — no separate run needed.

### Output

```json
{
    "name": "Desmet Studio's",
    "address": "Plantage Middenlaan 4A",
    "city": "Amsterdam",
    "postalCode": "1018 DD",
    "url": "https://trouwen.nl/contact/desmet-studio-s",
    "scrapedAt": "2026-07-26T03:05:14.336Z",
    "phone": "+31 205217100",
    "email": "info@desmet.tv",
    "website": "https://www.desmet.tv/events-en-locatie-verhuur/trouwfeest/",
    "imageUrl": "https://static.trouwen.nl/bruiloft-cdn/logo622/desmet-studio-s.webp",
    "description": "Desmet Studio's is de perfecte feestlocatie om jullie trouwdag mee af te sluiten!",
    "rating": 5,
    "reviewCount": 10,
    "category": "Trouwlocaties"
}
````

### How much does it cost?

Trouwen.nl Scraper uses CheerioCrawler (no browser needed):

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 venues | ~0.03 | ~$0.015 |
| 500 venues | ~0.12 | ~$0.06 |
| 1,000 venues | ~0.25 | ~$0.13 |
| 5,000 venues | ~1.10 | ~$0.55 |

The actor first collects vendor URLs from listing pages, then visits each detail page. Costs scale linearly.

### Can I integrate?

Push Dutch wedding vendor data into your tools:

- **Google Sheets** — build a sortable vendor database filtered by city, category, or rating
- **CRM / outreach tools** — feed vendor lists into a B2B sales pipeline for suppliers selling into the wedding industry
- **Zapier / Make** — trigger workflows when new vendors appear in a target city
- **PostgreSQL / MongoDB** — power a searchable vendor-finder app
- **Power BI / Tableau** — visualize vendor density and category distribution by Dutch city

### Can I use it as an API?

Yes. Build Dutch wedding vendor intelligence into your product:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/trouwen-scraper").call(run_input={
    "city": "utrecht",
    "category": "trouwfotografie",
    "maxResults": 200,
})

for vendor in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{vendor['name']} — {vendor['city']} — {vendor.get('website', 'no website')}")
```

**JavaScript:**

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/trouwen-scraper").call({
    city: "rotterdam",
    category: "trouwlocaties",
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const withPhone = items.filter((v) => v.phone);
console.log(`${withPhone.length}/${items.length} Rotterdam venues have a listed phone number`);
```

### FAQ

**Does this cover Bruiloft.nl too?**
Yes. Bruiloft.nl is run by the same company on the same underlying vendor database as Trouwen.nl — no separate run needed.

**Is phone number always available?**
No, but it's common. Vendors publish a direct number on most listings; where it's missing or the site renders a placeholder value, the field is left empty rather than filled with junk data.

**Are ratings and review counts available?**
Only for vendors that have received on-platform reviews. The `rating` and `reviewCount` fields are included but will be empty for newer or unreviewed listings.

**What categories are supported?**
20 categories across venues and vendors: trouwlocaties, bruidssuite, kastelen, hotels, restaurants, catering, dj-bruiloft, bruiloft-muziek, trouwfotografie, videograaf, weddingplanner, trouwambtenaar, decoratie, bruidsboeket, trouwauto, entertainment, foodtrucks, partyverhuur, photobooth, and notaris.

### Limitations

- Not every listing has a phone number, email, website, or review data — this directory relies on vendors to fill in optional fields.
- Some nationwide vendors (e.g. boat rental companies serving the whole country) list `city` as a region name rather than a specific address, leaving `address`/`postalCode` empty — this is a real gap in the source data, not a parsing error.
- Descriptions are short, vendor-written profile text, not long-form editorial copy.

### Related directory and wedding-industry scrapers

- [Hochzeitsportal24.de Scraper](https://apify.com/studio-amba/hochzeitsportal24-scraper) — German wedding vendor directory, same JSON-LD pattern
- [Hochzeitslocation.de Scraper](https://apify.com/studio-amba/hochzeitslocation-scraper) — German wedding venue directory
- [Resto.be Scraper](https://apify.com/studio-amba/resto-scraper) — venue/restaurant directory scraping with the same LocalBusiness pattern

### Your feedback

Want vendor reviews, a specific city bundled by default, or contact-form email harvesting? Open an issue on GitHub or contact us through the Apify platform. We prioritise improvements based on user demand.

# Actor input Schema

## `city` (type: `string`):

Dutch city or town to search, e.g. 'amsterdam', 'utrecht', 'rotterdam'. Defaults to 'amsterdam' if empty.

## `category` (type: `string`):

Vendor category to search within.

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

Trouwen.nl category/city listing pages or vendor detail pages. Overrides city + category if provided.

## `maxResults` (type: `integer`):

Maximum number of venues/vendors to return.

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

Proxy settings. Not required — Trouwen.nl has no anti-bot protection — but recommended for large runs.

## Actor input object example

```json
{
  "city": "amsterdam",
  "category": "trouwlocaties",
  "startUrls": [
    {
      "url": "https://trouwen.nl/trouwlocaties/amsterdam"
    }
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "city": "amsterdam",
    "startUrls": [
        {
            "url": "https://trouwen.nl/trouwlocaties/amsterdam"
        }
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/trouwen-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 = {
    "city": "amsterdam",
    "startUrls": [{ "url": "https://trouwen.nl/trouwlocaties/amsterdam" }],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/trouwen-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 '{
  "city": "amsterdam",
  "startUrls": [
    {
      "url": "https://trouwen.nl/trouwlocaties/amsterdam"
    }
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}' |
apify call studio-amba/trouwen-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/trouwen-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trouwen.nl Scraper — Dutch Wedding Venues & Vendors",
        "description": "Scrape wedding venues and vendor listings from Trouwen.nl, the Dutch wedding directory (also covers Bruiloft.nl — same company). Extract names, addresses, phone, email, website, ratings, and descriptions by city and category. No login needed.",
        "version": "0.1",
        "x-build-id": "H02SeRVLCKs8fHVgk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~trouwen-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-trouwen-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/studio-amba~trouwen-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-trouwen-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/studio-amba~trouwen-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-trouwen-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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Dutch city or town to search, e.g. 'amsterdam', 'utrecht', 'rotterdam'. Defaults to 'amsterdam' if empty."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "trouwlocaties",
                            "bruidssuite",
                            "kastelen",
                            "hotels",
                            "restaurants",
                            "catering",
                            "dj-bruiloft",
                            "bruiloft-muziek",
                            "trouwfotografie",
                            "videograaf",
                            "weddingplanner",
                            "trouwambtenaar",
                            "decoratie",
                            "bruidsboeket",
                            "trouwauto",
                            "entertainment",
                            "foodtrucks",
                            "partyverhuur",
                            "photobooth",
                            "notaris"
                        ],
                        "type": "string",
                        "description": "Vendor category to search within.",
                        "default": "trouwlocaties"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Trouwen.nl category/city listing pages or vendor detail pages. Overrides city + category if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of venues/vendors to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Not required — Trouwen.nl has no anti-bot protection — but recommended for large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
