# Apotheka Latvia Scraper - Pharmacy Products & Prices (`studio-amba/apotheka-lv-scraper`) Actor

Scrape products, prices, and availability from Apotheka.lv -- Latvia's largest pharmacy chain. Supports search queries and category browsing. Extracts medications, vitamins, supplements, and health products. No login required.

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

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Apotheka Latvia Scraper -- Pharmacy Products, Prices & Stock from Latvia's Largest Pharmacy Chain

Extract products, prices, brands, EAN codes, availability, and categories from [Apotheka.lv](https://www.apotheka.lv) -- the largest pharmacy chain in Latvia and part of the BENU/Phoenix Group operating across the Baltic states. The platform sells medications, vitamins, supplements, personal care, baby products, beauty items, and health devices.

### What is Apotheka Latvia Scraper?

Apotheka is the leading pharmacy retailer in Latvia with over 90 physical stores and a full online pharmacy (e-aptieka). As part of the Phoenix Group (Europe's largest pharmaceutical distributor), Apotheka is the primary pricing reference for the Latvian pharmacy and health products market. Their online catalogue covers thousands of products including non-prescription medications, dietary supplements, medical devices, and cosmetics.

This actor uses PlaywrightCrawler to handle Apotheka's Magento-based, JavaScript-rendered product pages. It extracts product data from JSON-LD structured data and HTML DOM parsing across search results, category pages, and individual product pages. No login or cookies required. What people build with it:

- **Pharmacy pricing intelligence** -- competing pharmacies and distributors monitor Apotheka's prices to maintain market-competitive positioning in the Latvian pharmaceutical sector.
- **Health product market research** -- supplement manufacturers and consumer health brands track how their products are priced, described, and positioned on Latvia's largest pharmacy platform.
- **Regulatory compliance monitoring** -- pharmaceutical industry bodies track product availability, pricing, and marketing claims on Latvian pharmacy platforms.
- **Product catalogue enrichment** -- health tech platforms and comparison sites use Apotheka's structured product data (EAN codes, descriptions, images) to populate their own databases.
- **Baltic market analysis** -- analysts studying the Baltic pharmacy market use Apotheka data alongside Estonian and Lithuanian pharmacy data for cross-border pricing comparisons.

### How to scrape Apotheka Latvia data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword in Latvian: `"vitamini"` (vitamins), `"ibuprofens"` (ibuprofen), `"saaukstesanas"` (cold) |
| `categoryUrl` | String | No | Apotheka.lv category URL, e.g. `https://www.apotheka.lv/produkti/veseliba/vitamini-un-mineralvielas/vitamini` |
| `maxResults` | Integer | No | Maximum products to return (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings (residential proxies with LV country code recommended) |

**Tips:**

- Use **Latvian keywords** for best coverage: `"vitamini"` (vitamins), `"minerali"` (minerals), `"skaistums"` (beauty), `"bernu"` (children's products), `"zobu"` (dental).
- Apotheka.lv uses Magento with JavaScript-rendered product pages. **Residential proxies** with Latvia country code give the best results.
- For category-wide scraping, browse apotheka.lv to find the category URL and paste it into `categoryUrl`.
- The actor tries JSON-LD structured data extraction first, falls back to DOM parsing, and can follow individual product links as a last resort.
- Default search query is `"vitamini"` (vitamins) when no input is provided -- the actor always returns data on empty input.

### Output

Each product record includes:

| Field | Type | Description |
|-------|------|-------------|
| `productName` | String | Full product name in Latvian |
| `brand` | String | Brand or manufacturer name |
| `price` | Number | Current selling price in EUR |
| `originalPrice` | Number | Original price before discount (if on sale) |
| `currency` | String | `"EUR"` |
| `inStock` | Boolean | Whether the product is currently in stock |
| `ean` | String | EAN/GTIN barcode for product identification |
| `category` | String | Product category from breadcrumbs |
| `imageUrl` | String | Primary product image URL |
| `url` | String | Direct product page link on apotheka.lv |
| `scrapedAt` | String | ISO 8601 timestamp when data was collected |

### Example output

```json
{
    "productName": "MULTI B STRONG, 100 tabletes B grupas vitamini",
    "brand": "Multi B Strong",
    "price": 8.99,
    "originalPrice": 11.49,
    "currency": "EUR",
    "inStock": true,
    "ean": "4751016200123",
    "category": "Vitamini",
    "imageUrl": "https://www.apotheka.lv/media/catalog/product/multi-b-strong-100.jpg",
    "url": "https://www.apotheka.lv/multi-b-strong-100-tabletes-b-grupas-vitamini-pmm0023545lv",
    "scrapedAt": "2026-06-09T14:30:00.000Z"
}
````

### How much does it cost?

This actor uses PlaywrightCrawler, which consumes more compute units than HTTP-based scrapers due to browser overhead.

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 50 products | ~0.10 | ~$0.05 |
| 100 products | ~0.20 | ~$0.10 |
| 500 products | ~0.80 | ~$0.40 |
| 1,000 products | ~1.50 | ~$0.75 |

Residential proxies add to the per-request proxy cost but improve reliability on the Magento platform.

### Can I integrate?

Connect Latvian pharmacy data to your tools:

- **Google Sheets** -- track pharmacy prices across the Latvian market
- **Slack** -- get alerts when specific medications or supplements go on sale
- **Zapier / Make** -- automate pricing updates for competing pharmacies or health stores
- **Webhooks** -- stream product data to your pharmacy comparison platform
- **PostgreSQL / BigQuery** -- build a historical Latvian pharmacy pricing database
- **Power BI** -- visualise pricing trends across pharmacy product categories

### Can I use it as an API?

Yes. Build Latvian pharmacy intelligence into your stack:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/apotheka-lv-scraper").call(run_input={
    "searchQuery": "vitamini",
    "maxResults": 50,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "LV"},
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    stock = "Pieejams" if product.get("inStock") else "Nav"
    print(f"{product['productName']} | {product['price']} EUR | {stock}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/apotheka-lv-scraper").call({
    searchQuery: "vitamini",
    maxResults: 50,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ["RESIDENTIAL"], apifyProxyCountry: "LV" },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const onSale = items.filter((p) => p.originalPrice && p.originalPrice > p.price);
console.log(`${onSale.length} products on sale:`);
onSale.forEach((p) => {
    const discount = Math.round((1 - p.price / p.originalPrice) * 100);
    console.log(`  ${p.productName} | ${p.price} EUR (was ${p.originalPrice}, -${discount}%)`);
});
```

### FAQ

**What products does Apotheka.lv sell?**
Apotheka sells non-prescription medications, vitamins, dietary supplements, medical devices, personal care products, baby products, beauty items, and health devices. Prescription medications are not available through the public online catalogue.

**Is all data in Latvian?**
Yes. Product names, descriptions, and categories are in Latvian. The platform serves the Latvian market.

**Why do I need residential proxies?**
Apotheka.lv runs on Magento with JavaScript-rendered product pages. Residential proxies with a Latvian IP address provide the most reliable access. The actor works without proxies for small runs but may encounter blocks on larger scraping jobs.

**What is the product URL format?**
Individual products use the pattern: `apotheka.lv/[product-name]-[pmm-code]lv`, for example `apotheka.lv/multi-b-strong-100-tabletes-b-grupas-vitamini-pmm0023545lv`.

**Does it handle pagination?**
Yes. The actor follows Magento's `?p=N` pagination pattern and "next page" links to crawl through multi-page search results and category listings.

### Limitations

- Apotheka.lv is a Magento store with JavaScript-rendered product pages. A PlaywrightCrawler (browser) is required, which uses more compute units than HTTP-only scrapers.
- Not all products have EAN codes in their structured data.
- Product availability may differ between online and physical Apotheka stores.
- Categories and product structures may change as Apotheka updates their website.
- The actor crawls sequentially (one page at a time) to maintain session stability and avoid detection.

### Related Baltic and European pharmacy scrapers

- [Apotheka Estonia Scraper](https://apify.com/studio-amba/apotheka-ee-scraper) -- Same pharmacy chain in Estonia
- [Apotea Scraper](https://apify.com/studio-amba/apotea-scraper) -- Sweden's largest online pharmacy
- [Apotek Hjartat Scraper](https://apify.com/studio-amba/apotekhjartat-scraper) -- Sweden's second-largest pharmacy chain
- [Multipharma Scraper](https://apify.com/studio-amba/multipharma-scraper) -- Belgian pharmacy chain
- [Newpharma Scraper](https://apify.com/studio-amba/newpharma-scraper) -- European online pharmacy
- [Shop Apotheke Scraper](https://apify.com/studio-amba/shopapotheke-scraper) -- Europe's largest online pharmacy (DE/AT/FR/BE/IT/CH)

### Your feedback

Need specific pharmacy categories, deeper product specification parsing, or cross-Baltic price comparisons? Open an issue on GitHub or contact us through the Apify platform. We build what users need.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword in Latvian (e.g., 'vitamini', 'ibuprofens', 'saaukstesanas'). Leave empty if using a category URL.

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

An Apotheka.lv category page URL to scrape. Example: https://www.apotheka.lv/produkti/veseliba/vitamini-un-mineralvielas/vitamini. If empty, the actor uses the search query.

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

Maximum number of products to return.

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

Proxy settings. Residential proxies with Latvia country code recommended for best results.

## Actor input object example

```json
{
  "searchQuery": "vitamini",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LV"
  }
}
```

# 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 = {
    "searchQuery": "vitamini",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "LV"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/apotheka-lv-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 = {
    "searchQuery": "vitamini",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "LV",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/apotheka-lv-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 '{
  "searchQuery": "vitamini",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LV"
  }
}' |
apify call studio-amba/apotheka-lv-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apotheka Latvia Scraper - Pharmacy Products & Prices",
        "description": "Scrape products, prices, and availability from Apotheka.lv -- Latvia's largest pharmacy chain. Supports search queries and category browsing. Extracts medications, vitamins, supplements, and health products. No login required.",
        "version": "0.1",
        "x-build-id": "CngHfjYRxw8PceNej"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~apotheka-lv-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-apotheka-lv-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~apotheka-lv-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-apotheka-lv-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~apotheka-lv-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-apotheka-lv-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword in Latvian (e.g., 'vitamini', 'ibuprofens', 'saaukstesanas'). Leave empty if using a category URL."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "An Apotheka.lv category page URL to scrape. Example: https://www.apotheka.lv/produkti/veseliba/vitamini-un-mineralvielas/vitamini. If empty, the actor uses the search query."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies with Latvia country code recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
