# Framar.bg Scraper - Bulgarian Pharmacy Products & Prices (`studio-amba/framar-bg-scraper`) Actor

Scrape products, prices, and availability from Framar.bg — Bulgaria's largest online pharmacy. Extract health products, supplements, cosmetics, and medications. Supports keyword search and category browsing. No login needed.

- **URL**: https://apify.com/studio-amba/framar-bg-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

## Framar.bg Scraper -- Bulgaria's Largest Online Pharmacy: Products, Prices & Stock Data

Extract products, prices, brands, availability, discounts, and descriptions from [Framar.bg](https://www.framar.bg) -- Bulgaria's biggest online pharmacy and health products platform, operated by a network of 50+ pharmacies across 12 Bulgarian cities, offering thousands of products including medications, supplements, cosmetics, and wellness products.

### What is Framar.bg Scraper?

Framar.bg is Bulgaria's most established health and pharmacy platform, combining an online pharmacy (apteka.framar.bg) with a health information portal, medical directory, and community forum. The pharmacy section carries a vast catalogue of prescription-free medications, dietary supplements, vitamins, skincare, baby care, and medical devices at competitive prices with nationwide delivery.

This actor uses Playwright browser automation to navigate Framar.bg's search and category pages, extract product listings, and visit individual product pages for full detail extraction. No login or cookies needed -- all data comes from publicly accessible pages. What people build with it:

- **Pharmacy pricing intelligence** -- competing Bulgarian pharmacies and health retailers monitor Framar's prices to maintain market-competitive positioning.
- **Health product market research** -- consumer health brands and supplement manufacturers track how their products are priced, described, and rated on Bulgaria's largest pharmacy platform.
- **Product catalogue enrichment** -- health tech platforms and comparison sites use Framar's structured product data (SKU codes, descriptions, images) to populate their own databases.
- **Regulatory compliance monitoring** -- pharmaceutical industry bodies track which products are available on Framar, at what prices, and how they are marketed to Bulgarian consumers.
- **Consumer trend analysis** -- market researchers analyse Framar's category structure, bestsellers, and pricing to understand Bulgarian consumer health and wellness preferences.

### What data does Framar.bg Scraper extract?

Each product record includes:

- :pill: **Product name** -- full product title in Bulgarian
- :label: **Brand** -- manufacturer or brand name
- :moneybag: **Price** -- current price in BGN (Bulgarian lev)
- :money_with_wings: **Original price** -- regular price before discount (if on sale)
- :chart_with_downwards_trend: **Discount** -- calculated discount percentage
- :currency_exchange: **Currency** -- BGN
- :white_check_mark: **Stock status** -- whether the product is in stock
- :camera: **Image URL** -- product image from Framar's CDN
- :page_facing_up: **Description** -- product description text
- :id: **SKU** -- product code or registration number
- :file_folder: **Category** -- breadcrumb category path
- :link: **URL** -- direct product link on apteka.framar.bg

### How to scrape Framar.bg data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword: `"витамини"` (vitamins), `"ибупрофен"` (ibuprofen), `"крем за лице"` (face cream) |
| `categoryUrl` | String | No | Framar category URL, e.g. `https://apteka.framar.bg/категории/витамини-и-минерали` |
| `maxResults` | Integer | No | Maximum products to return (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings (Bulgarian residential proxies recommended) |

**Tips:**

- Use **Bulgarian keywords** for best coverage: `"витамини"` (vitamins), `"козметика"` (cosmetics), `"бебешки"` (baby products), `"болкоуспокояващи"` (painkillers).
- If no search query or category URL is provided, the actor defaults to searching for `"витамини"` (vitamins).
- For category-wide scraping, browse apteka.framar.bg to find the category URL and paste it into `categoryUrl`.
- Residential proxies with Bulgarian geolocation improve reliability.

### Output

```json
{
    "productName": "АБОФАРМА ВИТАМИНИ А - Z таблетки * 60",
    "brand": "ABOPHARMA",
    "price": 16.45,
    "currency": "BGN",
    "originalPrice": 32.17,
    "discount": "-49%",
    "category": "Е-аптека > Хранителни добавки > Витамини и минерали",
    "inStock": true,
    "imageUrl": "https://static.framar.bg/product/abopharma-vitaminesa-to-z.jpg",
    "url": "https://apteka.framar.bg/30006875/абофарма-витамини-а-z-таблетки-60",
    "productDescription": "Комплексна формула от 27 витамина, минерала и растителни екстракти...",
    "sku": "30006875",
    "scrapedAt": "2026-06-09T10:00:00.000Z"
}
````

### How much does it cost?

The actor uses Playwright (browser-based crawling) for reliable extraction. Cost depends on the number of products scraped:

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 50 products | ~0.15 | ~$0.08 |
| 100 products | ~0.30 | ~$0.15 |
| 500 products | ~1.20 | ~$0.60 |
| 1,000 products | ~2.40 | ~$1.20 |

Residential proxy usage adds to the per-request cost but improves reliability.

### Can I integrate?

Connect Bulgarian pharmacy data to your tools:

- **Google Sheets** -- track prices on your product portfolio across the Bulgarian pharmacy market
- **Slack** -- get alerts when specific health products go on sale on Framar
- **Zapier / Make** -- automate pricing updates for your competing pharmacy or health store
- **Webhooks** -- stream product data to your own health product comparison platform
- **PostgreSQL / BigQuery** -- build a historical Bulgarian health product pricing database
- **Power BI** -- visualise pricing trends in Bulgarian pharmacy categories

### Can I use it as an API?

Yes. Build Bulgarian health product intelligence into your stack:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/framar-bg-scraper").call(run_input={
    "searchQuery": "витамини",
    "maxResults": 50,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    stock = "Налично" if product.get('inStock') else "Изчерпано"
    print(f"{product['productName']} | {product['price']} BGN | {stock}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/framar-bg-scraper").call({
    searchQuery: "витамини",
    maxResults: 50,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ["RESIDENTIAL"] },
});

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} BGN (was ${p.originalPrice}, -${discount}%)`);
});
```

### FAQ

**Does Framar.bg sell prescription medications?**
Framar.bg sells both prescription-free (OTC) medications and certain prescription drugs through their licensed pharmacy network. This actor scrapes publicly accessible product pages, which are primarily non-prescription items, supplements, and health products.

**Is all data in Bulgarian?**
Yes. Product names, descriptions, and categories are in Bulgarian (Cyrillic script). The platform serves the Bulgarian market exclusively.

**Why do I need residential proxies?**
Residential proxies with Bulgarian geolocation improve success rates and page load speed. The actor works without them for small volumes, but for reliable production use, residential proxies are recommended.

**What is the price currency?**
All prices are in BGN (Bulgarian lev). Some product pages also display EUR equivalents, but the actor extracts the BGN price as the primary value.

**How does the scraping work?**
The actor first visits search or category listing pages to collect product URLs, then visits each product detail page to extract full information including description, brand, category breadcrumbs, and stock status.

**Can I scrape specific categories?**
Yes. Browse apteka.framar.bg, find the category URL you want, and paste it into the `categoryUrl` input field. The actor will paginate through that category.

### Limitations

- Product names and descriptions are in Bulgarian (Cyrillic). No translation is applied.
- Some products may lack brand, description, or category data if the Framar listing is incomplete.
- The actor caps pagination to prevent infinite loops.
- Framar.bg uses multiple subdomains (apteka.framar.bg, zdrave.framar.bg) -- the actor handles the routing automatically.
- Very large category scrapes (1000+ products) may take longer due to per-page browser rendering.

### Related European pharmacy scrapers

- [Apotea Scraper](https://apify.com/studio-amba/apotea-scraper) -- Sweden's largest online pharmacy
- [Apotek Hjartat Scraper](https://apify.com/studio-amba/apotekhjartat-scraper) -- Swedish pharmacy chain with 390+ stores
- [Aponeo Scraper](https://apify.com/studio-amba/aponeo-scraper) -- German online pharmacy
- [Apoteket Scraper](https://apify.com/studio-amba/apoteket-scraper) -- Sweden's state-owned pharmacy chain

### Your feedback

Need specific health product categories, deeper product specification parsing, or price history tracking? 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 (e.g., 'витамини', 'ибупрофен', 'крем за лице'). Uses Framar's search page.

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

A Framar.bg category page URL to scrape. Example: https://apteka.framar.bg/%D0%BA%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D0%B8/%D0%B2%D0%B8%D1%82%D0%B0%D0%BC%D0%B8%D0%BD%D0%B8-%D0%B8-%D0%BC%D0%B8%D0%BD%D0%B5%D1%80%D0%B0%D0%BB%D0%B8

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

Maximum number of products to return.

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

Proxy settings. Recommended: use Apify residential proxies for best results.

## Actor input object example

```json
{
  "searchQuery": "витамини",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BG"
  }
}
```

# 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": "витамини",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BG"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/framar-bg-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": "витамини",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BG",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/framar-bg-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": "витамини",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BG"
  }
}' |
apify call studio-amba/framar-bg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Framar.bg Scraper - Bulgarian Pharmacy Products & Prices",
        "description": "Scrape products, prices, and availability from Framar.bg — Bulgaria's largest online pharmacy. Extract health products, supplements, cosmetics, and medications. Supports keyword search and category browsing. No login needed.",
        "version": "0.1",
        "x-build-id": "6eTJBSxyudYjTluby"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~framar-bg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-framar-bg-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~framar-bg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-framar-bg-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~framar-bg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-framar-bg-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 (e.g., 'витамини', 'ибупрофен', 'крем за лице'). Uses Framar's search page."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A Framar.bg category page URL to scrape. Example: https://apteka.framar.bg/%D0%BA%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D0%B8/%D0%B2%D0%B8%D1%82%D0%B0%D0%BC%D0%B8%D0%BD%D0%B8-%D0%B8-%D0%BC%D0%B8%D0%BD%D0%B5%D1%80%D0%B0%D0%BB%D0%B8"
                    },
                    "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. Recommended: use Apify residential proxies 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
