# SS.com Scraper: Latvia Classified Ads & Prices (`getascraper/ss-com-latvia-scraper`) Actor

Scrape classified ads from ss.com, Latvia's largest listings portal. Get listing titles, prices in EUR, item specs like car year, mileage, rooms, and floor, plus image links and ad URLs. Search any category by URL, filter by price and year, then export to Excel, Google Sheets, CSV, or JSON.

- **URL**: https://apify.com/getascraper/ss-com-latvia-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** E-commerce, Automation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.74 / 1,000 listing records

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

## ss.com Latvia Scraper

Get live ss.com and ss.lv classified listings, prices in EUR, car mileage, and apartment details, ready for your spreadsheet in under 60 seconds.

ss.com (also known as ss.lv) is Latvia's largest classified ads portal. This scraper pulls listings across many sections in one run: cars, motorcycles, flats, houses, land, commercial property, mobile phones, jobs, and animals. You point it at a category, a search keyword, or a specific page, and you get clean, structured records.

### What does the Actor do?

This Actor turns messy classified ad pages into a tidy table you can analyze. Every listing comes back with its ID, title, price in EUR, and direct link. Car sections add vehicle details. Property sections add real estate details.

You can run it three ways:

* Pick a category and a price range from the form.
* Paste a single ss.com category or search page URL.
* Paste a list of ss.com URLs to scrape several sections at once.

The output is flat and spreadsheet friendly. Open it in Excel, Google Sheets, or load it into your own database.

### Who is this for?

* **I am a used-car dealer** comparing second-hand prices across ss.com to spot under-priced listings, filtering by year, fuel type, and mileage in bulk.
* **I am a car reseller** tracking how fast specific models sell in Latvia so I know which cars to buy now and flip later.
* **I am a real estate analyst** monitoring flat and house prices per square meter across Riga and the regions to brief my clients on market shifts.
* **I am a lead-generation specialist** building a list of fresh listings across the Baltic market for my outreach team.
* **I am a market researcher** measuring price trends in mobile phones, jobs, and animals to publish a quarterly Latvia classifieds report.

### Input

You can leave every field blank and the Actor will guide you, or combine fields to narrow your results. Use a category for a quick start, or paste your own URLs for full control.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `query` | string | No | A search keyword to find matching ads, for example a car brand or a phone model. |
| `category` | enum | No | Which section to scrape: Cars, Motorcycles, Flats, Houses, Land, Commercial, Mobile phones, Jobs, or Animals. |
| `categoryUrl` | string | No | Paste one specific ss.com category page URL to scrape that exact section. |
| `startUrls` | array of URLs | No | Paste several ss.com URLs to scrape multiple sections or searches in a single run. |
| `minPrice` | integer | No | Minimum price in EUR. Listings below this value are skipped. |
| `maxPrice` | integer | No | Maximum price in EUR. Listings above this value are skipped. |
| `minYear` | integer | No | Minimum production year. Applies when scraping cars to filter out older vehicles. |
| `maxYear` | integer | No | Maximum production year. Applies when scraping cars to filter out newer vehicles. |
| `maxItems` | integer | No | Cap on how many listings to return per run. Useful for a quick test before a large pull. |
| `proxyConfiguration` | object | No | Proxy settings for reliable access. The default works for most runs. |

### Output

Every listing returns the common fields below. Car and motorcycle sections add the vehicle fields. Flat, house, land, and commercial sections add the property fields. Fields that do not apply to a section are simply left out.

#### Fields on every listing

| Field | Type | Description |
| --- | --- | --- |
| `listing_id` | string | The unique ad ID from ss.com. |
| `title` | string | The ad headline as shown on the listing. |
| `price_eur` | number | Price in EUR. Present on roughly 90 percent or more of listings. Some ads are priced on request and have no value. |
| `currency` | string | Always "EUR". |
| `product_url` | string | Direct link to the full ad page. |
| `scraped_at` | string | Timestamp of when the record was collected. |

#### Extra fields on cars and motorcycles

| Field | Type | Description |
| --- | --- | --- |
| `model` | string | The vehicle model name. |
| `year` | number | Production year of the vehicle. |
| `engine_volume` | string | Engine size and fuel marker, for example "2.8D". |
| `fuel` | string | Fuel type, for example "diesel" or "petrol". |
| `mileage` | number | Distance driven, in kilometers. |

#### Extra fields on flats, houses, land, and commercial property

| Field | Type | Description |
| --- | --- | --- |
| `rooms` | number | Number of rooms in the property. |
| `area_m2` | number | Floor area in square meters. |
| `floor` | number | The floor the property is on. |
| `total_floors` | number | Total number of floors in the building. |
| `building_type` | string | Construction type of the building. |
| `series` | string | The building series or project name. |
| `price_per_m2` | number | Price per square meter in EUR. |
| `city` | string | City or area where the property is located. |
| `street` | string | Street address of the property. |

#### Example car listing

```json
{
  "listing_id": "ABcDeFg",
  "title": "BMW X5, 2014, 2.8D",
  "model": "BMW X5",
  "year": 2014,
  "engine_volume": "2.8D",
  "fuel": "diesel",
  "mileage": 187000,
  "price_eur": 14500,
  "currency": "EUR",
  "product_url": "https://www.ss.com/msg/en/transport/cars/bmw/x5/abcdefg.html",
  "scraped_at": "2026-06-25T09:14:02.000Z"
}
````

#### Example flat listing

```json
{
  "listing_id": "HiJkLmN",
  "title": "3-room flat, Riga, 68 m2",
  "rooms": 3,
  "area_m2": 68,
  "floor": 4,
  "total_floors": 9,
  "building_type": "Brick",
  "series": "Specpr.",
  "price_per_m2": 1320,
  "city": "Riga",
  "street": "Brivibas iela",
  "price_eur": 89800,
  "currency": "EUR",
  "product_url": "https://www.ss.com/msg/en/real-estate/flats/riga/centre/hijklmn.html",
  "scraped_at": "2026-06-25T09:14:05.000Z"
}
```

### Pricing

This Actor is pay per result. You are billed only for the listings successfully saved to your dataset. Empty runs cost nothing, so testing a search before a large pull carries no risk. There are no monthly subscriptions and no fixed fees.

### Frequently asked questions

##### Does the scraper get blocked?

No. The Actor routes traffic through reliable proxy connections so it can collect ss.com and ss.lv listings steadily without getting blocked. The default proxy setting works for most runs.

##### Does it extract private phone numbers?

It collects the public details shown on each listing card and ad page, including the ID, title, price, and the car or property specs. It does not bypass any login or reveal information that ss.com hides behind a click.

##### How fresh is the data?

Every run reads the live ss.com pages at that moment, so your results reflect what is on the site right now. Run it on a schedule to track price changes and new listings over time.

##### Which categories are supported?

The scraper covers many ss.com sections: cars, motorcycles, flats, houses, land, commercial property, mobile phones, jobs, and animals. Car sections return vehicle specs and property sections return real estate specs.

# Actor input Schema

## `query` (type: `string`):

Keyword to filter listings within the selected category (for example audi or diesel). Leave empty to scrape the whole category. Applied as the ss.com txt search parameter.

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

Top-level ss.com category to scrape. Ignored when a Category URL or Start URLs are provided. The scraper auto-discovers sub-categories for broad categories like cars.

## `categoryUrl` (type: `string`):

Optional direct ss.com category, sub-category, or filtered URL. Overrides the Category selector. Apply any filters in your browser on ss.com and copy-paste the resulting URL here.

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

Optional list of additional specific URLs to scrape in parallel.

## `minPrice` (type: `integer`):

Filter results to only include classifieds with a price greater than or equal to this value in Euros.

## `maxPrice` (type: `integer`):

Filter results to only include classifieds with a price less than or equal to this value in Euros.

## `minYear` (type: `integer`):

Filter results to only include classifieds with a manufacturing year greater than or equal to this value.

## `maxYear` (type: `integer`):

Filter results to only include classifieds with a manufacturing year less than or equal to this value.

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

Maximum total classified listings to extract.

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

Rotating proxy settings to avoid access issues. Standard proxies are fully sufficient.

## Actor input object example

```json
{
  "query": "",
  "category": "cars",
  "categoryUrl": "https://www.ss.com/en/transport/cars/audi/",
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "query": "",
    "category": "cars",
    "categoryUrl": "https://www.ss.com/en/transport/cars/audi/",
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/ss-com-latvia-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 = {
    "query": "",
    "category": "cars",
    "categoryUrl": "https://www.ss.com/en/transport/cars/audi/",
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/ss-com-latvia-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 '{
  "query": "",
  "category": "cars",
  "categoryUrl": "https://www.ss.com/en/transport/cars/audi/",
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call getascraper/ss-com-latvia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SS.com Scraper: Latvia Classified Ads & Prices",
        "description": "Scrape classified ads from ss.com, Latvia's largest listings portal. Get listing titles, prices in EUR, item specs like car year, mileage, rooms, and floor, plus image links and ad URLs. Search any category by URL, filter by price and year, then export to Excel, Google Sheets, CSV, or JSON.",
        "version": "0.1",
        "x-build-id": "5KsqMJwiUz7y74HqD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~ss-com-latvia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-ss-com-latvia-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/getascraper~ss-com-latvia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-ss-com-latvia-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/getascraper~ss-com-latvia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-ss-com-latvia-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword to filter listings within the selected category (for example audi or diesel). Leave empty to scrape the whole category. Applied as the ss.com txt search parameter.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "cars",
                            "motorcycles",
                            "flats",
                            "houses",
                            "land",
                            "commercial",
                            "mobile_phones",
                            "jobs",
                            "animals"
                        ],
                        "type": "string",
                        "description": "Top-level ss.com category to scrape. Ignored when a Category URL or Start URLs are provided. The scraper auto-discovers sub-categories for broad categories like cars.",
                        "default": "cars"
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "Optional direct ss.com category, sub-category, or filtered URL. Overrides the Category selector. Apply any filters in your browser on ss.com and copy-paste the resulting URL here.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional list of additional specific URLs to scrape in parallel.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter results to only include classifieds with a price greater than or equal to this value in Euros."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter results to only include classifieds with a price less than or equal to this value in Euros."
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Filter results to only include classifieds with a manufacturing year greater than or equal to this value."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Filter results to only include classifieds with a manufacturing year less than or equal to this value."
                    },
                    "maxItems": {
                        "title": "Maximum listings limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total classified listings to extract.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Rotating proxy settings to avoid access issues. Standard proxies are fully sufficient.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
