# Hitta.se Business Directory Scraper (`automation-lab/hitta-se-business-directory-scraper`) Actor

Scrape Swedish business listings, contacts, addresses, ratings, and coordinates from Hitta.se search results.

- **URL**: https://apify.com/automation-lab/hitta-se-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

## Hitta.se Business Directory Scraper

Scrape public Swedish business listings from Hitta.se search results. Export company names, phone numbers, public emails, addresses, categories, ratings, review counts, coordinates, and profile URLs for lead generation and market research.

### What does Hitta.se Business Directory Scraper do?

Hitta.se Business Directory Scraper turns Hitta.se company search result pages into structured datasets.

It searches combinations such as `pizza + Stockholm`, `tandläkare + Göteborg`, or direct Hitta.se search URLs copied from your browser.

The actor reads public search-result data and saves one row per company.

Typical output includes:

- 🏢 Company name
- ☎️ Phone number and all phone numbers
- ✉️ Public email when Hitta.se exposes it
- 🌐 Website when present
- 📍 Address, city, municipality, county, latitude, and longitude
- ⭐ Rating and review count
- 🏷️ Category information
- 🔗 Hitta.se profile URL and source search URL

### Who is it for?

Sales teams use this actor to build Sweden-focused prospect lists.

Growth marketers use it to discover local businesses by niche and location.

Recruiters and partnership teams use it to map companies in Swedish cities.

Agencies use it to collect local business contact details before outreach campaigns.

Data teams use it to monitor regional market coverage and category density.

### Why use this actor?

Hitta.se is one of Sweden's best-known business and contact directories.

Manual searching is slow when you need hundreds or thousands of local companies.

This actor automates the repetitive search, pagination, extraction, and export work.

It is HTTP-only, lightweight, and designed for affordable lead-generation runs.

### Example use cases

- Find restaurants in Stockholm, Malmö, Göteborg, and Uppsala.
- Collect dentist offices by city for a healthcare SaaS campaign.
- Build a list of construction firms in Swedish regions.
- Compare review counts and ratings across local service categories.
- Enrich CRM workflows with public Hitta.se profile URLs and coordinates.

### Data fields

| Field | Description |
| --- | --- |
| `name` | Company name shown on Hitta.se |
| `url` | Hitta.se profile URL |
| `phone` | Primary phone number |
| `phones` | All phone numbers found in the listing |
| `email` | Primary public email when available |
| `emails` | All public emails found in the listing |
| `website` | Company website when present |
| `address` | Combined address string |
| `street` | Street and street number |
| `postalCode` | Postal code |
| `city` | City |
| `municipality` | Municipality/community |
| `county` | County |
| `category` | Primary category |
| `categories` | Category list |
| `rating` | Hitta.se review score |
| `reviewCount` | Number of reviews |
| `latitude` | Latitude |
| `longitude` | Longitude |
| `searchTerm` | Search keyword used |
| `locationQuery` | Location query used |
| `sourceUrl` | Search result page URL |
| `page` | Search result page number |

### How much does it cost to scrape Hitta.se business leads?

This actor uses pay-per-event pricing.

There is a $0.005 start charge per run and a tiered per-result charge for each company saved.

BRONZE users pay $0.0005 per extracted company listing, with lower per-result rates on higher Apify tiers.

The input prefill is intentionally small so your first run is inexpensive.

### How to use Hitta.se Business Directory Scraper

1. Open the actor on Apify.
2. Enter one or more search terms, such as `pizza` or `byggfirma`.
3. Enter one or more Swedish locations, such as `Stockholm` or `Göteborg`.
4. Set `Maximum companies` to the number of listings you need.
5. Run the actor.
6. Download results as JSON, CSV, Excel, XML, or via API.

### Input options

#### Search terms

Use Swedish keywords, industries, or service categories.

Examples:

- `pizza`
- `tandläkare`
- `frisör`
- `byggfirma`
- `advokat`

#### Locations

Use Swedish city or area names.

Examples:

- `Stockholm`
- `Göteborg`
- `Malmö`
- `Uppsala`
- `Västerås`

#### Start URLs

You can also paste Hitta.se search result URLs.

This is useful when you already configured a search manually in your browser.

#### Maximum companies

This is a global cap across all searches.

If you enter multiple search terms and locations, the actor stops when it reaches this total.

### Example input

```json
{
  "searchTerms": ["pizza"],
  "locations": ["Stockholm"],
  "maxResults": 25
}
````

### Example output

```json
{
  "name": "Restaurang Erikslund",
  "phone": "0921-161 62",
  "email": "example@example.com",
  "address": "Allégatan 50, 96167 Boden",
  "city": "Boden",
  "category": "Restaurang",
  "rating": 4.9,
  "reviewCount": 30,
  "latitude": 65.8265,
  "longitude": 21.71464,
  "url": "https://www.hitta.se/restaurang-erikslund"
}
```

### Tips for better results

Use Swedish category terms when possible.

Run broader terms first, then narrow down with more specific terms.

Use multiple locations to create regional lists in one run.

Keep test runs small before launching a large CRM export.

Review email availability because not every Hitta.se listing publishes an email address.

### Integrations

Export CSV files into HubSpot, Salesforce, Pipedrive, Airtable, or Google Sheets.

Use Apify webhooks to send completed datasets to Make or Zapier.

Use the Apify API to refresh Swedish prospect lists on a schedule.

Combine this actor with email verification or enrichment workflows after export.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hitta-se-business-directory-scraper').call({
  searchTerms: ['pizza'],
  locations: ['Stockholm'],
  maxResults: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/hitta-se-business-directory-scraper').call(run_input={
    'searchTerms': ['pizza'],
    'locations': ['Stockholm'],
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~hitta-se-business-directory-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["pizza"],"locations":["Stockholm"],"maxResults":25}'
```

### MCP usage

Use this actor from AI tools through Apify MCP.

Claude Code MCP URL:

`https://mcp.apify.com/?tools=automation-lab/hitta-se-business-directory-scraper`

Claude Desktop can use the same MCP endpoint with your Apify token.

Claude Code setup example:

```bash
claude mcp add apify-hitta-se https://mcp.apify.com/?tools=automation-lab/hitta-se-business-directory-scraper
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-hitta-se": {
      "url": "https://mcp.apify.com/?tools=automation-lab/hitta-se-business-directory-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 pizza restaurants in Stockholm and return phone numbers."
- "Scrape dentists in Göteborg from Hitta.se and summarize cities with the most listings."
- "Build a CSV of Swedish construction companies in Malmö."

### Data quality notes

The actor extracts public data that Hitta.se exposes in search results.

Some listings do not include email addresses or websites.

Ratings are present only when Hitta.se has review data for a company.

Coordinates are usually available for listings with a visiting address.

### Performance notes

The actor is HTTP-only and does not launch a browser.

Pagination is handled with Hitta.se search result pages.

The default memory is 256 MB to keep compute cost low.

### Legality

This actor scrapes publicly available business listing data.

You are responsible for using the data lawfully and respecting privacy, marketing, and data-protection rules that apply to your use case.

Do not use scraped contact data for unlawful spam or prohibited outreach.

### FAQ

#### Is Hitta.se Business Directory Scraper a lead scraper?

Yes. It is designed for Swedish company lead lists from public Hitta.se business search results.

#### Does it scrape personal profiles?

No. The MVP focuses on company listings only.

### Troubleshooting

#### Why do some rows have no email?

Hitta.se does not expose an email address for every company. The actor leaves email fields empty when no public email is present.

#### Why did I get fewer results than requested?

The source may have fewer matching company listings than your `maxResults`, or the same company may appear across multiple searches and be deduplicated.

#### Can I scrape people results?

No. Version 0.1 focuses on company listings for lead generation. Person-result scraping is intentionally excluded.

### Related scrapers

- [Gelbe Seiten Scraper](https://apify.com/automation-lab/gelbeseiten-scraper)
- [PagesJaunes France Business Scraper](https://apify.com/automation-lab/pagesjaunes-france-business-scraper)
- [WLW Germany Supplier Directory Scraper](https://apify.com/automation-lab/wlw-de-supplier-directory-scraper)
- [Website Emails Scraper](https://apify.com/automation-lab/website-emails-scraper)
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder)

### Changelog

#### 0.1

Initial version for Hitta.se company search result extraction.

### Support

If you need a new field from public Hitta.se listings, open an issue on the Apify actor page.

### Roadmap

Potential future additions include profile-page enrichment, more category normalization, and optional review extraction.

### Summary

Hitta.se Business Directory Scraper helps you collect Swedish local-business leads quickly and consistently.

It is best for sales prospecting, market mapping, local SEO research, and regional CRM enrichment.

# Actor input Schema

## `searchTerms` (type: `array`):

Business categories or keywords to search on Hitta.se, for example pizza, tandläkare, byggfirma, frisör.

## `locations` (type: `array`):

Swedish cities, regions, or areas to combine with each search term. Leave empty when using only Start URLs.

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

Optional Hitta.se search result URLs. Use this for exact searches copied from your browser.

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

Maximum number of unique company listings to save across all searches.

## Actor input object example

```json
{
  "searchTerms": [
    "pizza"
  ],
  "locations": [
    "Stockholm"
  ],
  "startUrls": [
    {
      "url": "https://www.hitta.se/s%C3%B6k?vad=pizza&var=Stockholm&typ=ftg"
    }
  ],
  "maxResults": 20
}
```

# 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 = {
    "searchTerms": [
        "pizza"
    ],
    "locations": [
        "Stockholm"
    ],
    "startUrls": [
        {
            "url": "https://www.hitta.se/s%C3%B6k?vad=pizza&var=Stockholm&typ=ftg"
        }
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hitta-se-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 = {
    "searchTerms": ["pizza"],
    "locations": ["Stockholm"],
    "startUrls": [{ "url": "https://www.hitta.se/s%C3%B6k?vad=pizza&var=Stockholm&typ=ftg" }],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hitta-se-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 '{
  "searchTerms": [
    "pizza"
  ],
  "locations": [
    "Stockholm"
  ],
  "startUrls": [
    {
      "url": "https://www.hitta.se/s%C3%B6k?vad=pizza&var=Stockholm&typ=ftg"
    }
  ],
  "maxResults": 20
}' |
apify call automation-lab/hitta-se-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hitta.se Business Directory Scraper",
        "description": "Scrape Swedish business listings, contacts, addresses, ratings, and coordinates from Hitta.se search results.",
        "version": "0.1",
        "x-build-id": "4NGRypyYihEtjbtC7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hitta-se-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hitta-se-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~hitta-se-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hitta-se-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~hitta-se-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hitta-se-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Business categories or keywords to search on Hitta.se, for example pizza, tandläkare, byggfirma, frisör.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Swedish cities, regions, or areas to combine with each search term. Leave empty when using only Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Hitta.se search result URLs. Use this for exact searches copied from your browser.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique company listings to save across all searches.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```