# Farmacia Tei Scraper - Romanian Pharmacy Products (`studio-amba/farmacia-tei-scraper`) Actor

Scrape products, prices, discounts, and availability from Farmacia Tei (comenzi.farmaciatei.ro) — Romania's largest online pharmacy with 50,000+ products. Extract OTC medications, supplements, cosmetics, and health products. No login needed.

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

## Farmacia Tei Scraper -- Romania's Largest Online Pharmacy: Products, Prices & Discounts

Extract products, prices, discounts, brands, availability, and descriptions from [Farmacia Tei](https://comenzi.farmaciatei.ro) -- Romania's largest online pharmacy with over 50,000 products spanning OTC medications, supplements, cosmetics, veterinary products, and medical devices.

### What is Farmacia Tei Scraper?

Farmacia Tei has been a pioneer in Romanian e-commerce pharmacy since 1992. With 500+ employees and one of the highest-traffic health e-commerce sites in Romania, it serves as the primary pricing reference for the Romanian pharmacy and health products market. The platform offers everything from prescription-free medications and vitamins to dermatological cosmetics, baby care, diet supplements, and pet health products.

This actor uses Playwright-based browser automation to extract structured product data from Farmacia Tei's search results and category pages. No login or account is needed -- all data comes from publicly accessible product listings. What people build with it:

- **Pharmacy pricing intelligence** -- competing Romanian pharmacies and health retailers monitor Farmacia Tei's prices to maintain competitive positioning in the local market.
- **Health product market research** -- pharmaceutical companies and supplement brands track how their products are priced, described, and positioned on Romania's largest online pharmacy.
- **Product catalogue enrichment** -- health tech platforms and comparison sites use Farmacia Tei's structured product data to populate their Romanian product databases.
- **Discount and promotion tracking** -- retailers and consumers track sales, discount percentages, and promotional campaigns across health product categories.
- **Consumer trend analysis** -- market researchers analyze Farmacia Tei's bestsellers, pricing patterns, and category structure to understand Romanian consumer health preferences.

### What data does Farmacia Tei Scraper extract?

Each product record includes:

- **Product name** -- full product name including dosage, form, and manufacturer
- **Brand** -- manufacturer or brand name (linked to brand page)
- **Price** -- current selling price in RON (Romanian lei)
- **Original price** -- regular price before discount, when applicable
- **Discount** -- discount percentage (e.g., "- 25%")
- **Currency** -- RON
- **Stock status** -- whether the product is currently available
- **Image URL** -- primary product image from Farmacia Tei's media CDN
- **Category** -- product category breadcrumb path
- **Product description** -- description or medical indication text
- **URL** -- direct link to the product page on comenzi.farmaciatei.ro

### How to scrape Farmacia Tei data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword: `"ibuprofen"`, `"vitamina C"`, `"crema de fata"` |
| `categoryUrl` | String | No | Farmacia Tei category URL, e.g. `https://comenzi.farmaciatei.ro/medicamente-otc/reumatologie-si-traumatisme` |
| `maxResults` | Integer | No | Maximum products to return (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings (Romanian residential proxies recommended) |

**Tips:**

- Use **Romanian keywords** for best coverage: `"vitamine"` (vitamins), `"suplimente"` (supplements), `"cosmetice"` (cosmetics), `"medicamente"` (medications), `"ingrijire corporala"` (body care).
- For category-wide scraping, browse comenzi.farmaciatei.ro to find the category URL and paste it into `categoryUrl`.
- **Residential proxies** with Romania (`RO`) country setting provide the best reliability.
- The actor automatically scrolls the page to load all products. Farmacia Tei displays many products on a single search results page.
- No login or account needed. All data is from publicly accessible pages.

### Output

```json
{
    "productName": "Ibuprofen Arena, 400 mg, 10 capsule, Arena Group",
    "brand": "ARENA GROUP",
    "price": 16.00,
    "currency": "RON",
    "originalPrice": null,
    "discount": null,
    "category": "Medicamente Otc > Reumatologie Si Traumatisme > Traumatisme Si Dureri Musculare",
    "inStock": true,
    "imageUrl": "https://media.farmaciatei.ro/gallery/12345/medium/ibuprofen-arena-400mg.png",
    "url": "https://comenzi.farmaciatei.ro/medicamente-otc/reumatologie-si-traumatisme/traumatisme-si-dureri-musculare/ibuprofen-arena-400-mg-10-capsule-arena-group-p364537",
    "productDescription": "Ibuprofen Arena este un medicament antiinflamator nesteroidian utilizat pentru ameliorarea durerii si inflamatiei...",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
````

Example with discount:

```json
{
    "productName": "Gerovital H3 Derma+ Sun Crema Protectie Solara SPF50, 50 ml",
    "brand": "FARMEC",
    "price": 28.28,
    "currency": "RON",
    "originalPrice": 43.50,
    "discount": "- 35%",
    "category": "Cosmetice > Protectie Solara",
    "inStock": true,
    "imageUrl": "https://media.farmaciatei.ro/gallery/56789/medium/gerovital-h3-derma-sun.png",
    "url": "https://comenzi.farmaciatei.ro/cosmetice/protectie-solara/gerovital-h3-derma-sun-crema-protectie-solara-spf50-50-ml-farmec-p456789",
    "productDescription": "Crema cu protectie solara foarte inalta SPF50...",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
```

### How much does it cost?

The actor uses Playwright (browser-based crawling) which consumes more compute units than HTTP-only scrapers. Costs depend on the number of pages loaded:

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

Residential proxy costs are additional. Romanian residential proxies may add ~$0.003-0.005 per request.

### Can I integrate?

Connect Romanian pharmacy data to your tools:

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

### Can I use it as an API?

Yes. Build Romanian pharmacy intelligence into your stack:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/farmacia-tei-scraper").call(run_input={
    "searchQuery": "vitamina C",
    "maxResults": 50,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    discount = product.get('discount', 'no discount')
    print(f"{product['productName']} | {product['price']} RON | {discount}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/farmacia-tei-scraper").call({
    searchQuery: "vitamina C",
    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) => {
    console.log(`  ${p.productName} | ${p.price} RON (was ${p.originalPrice} RON, ${p.discount})`);
});
```

### FAQ

**Does Farmacia Tei sell prescription medications?**
Farmacia Tei lists both OTC (over-the-counter) and prescription medications. This actor scrapes product data from public product pages. Prescription products are marked with an "RX" badge and require a medical prescription for purchase.

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

**Why do I need residential proxies?**
Residential proxies, especially from Romania, provide the most reliable access to Farmacia Tei's website. They reduce the chance of being blocked or served different content compared to datacenter proxies.

**Can I scrape specific categories?**
Yes. Paste any Farmacia Tei category URL into the `categoryUrl` input field. For example: `https://comenzi.farmaciatei.ro/medicamente-otc/reumatologie-si-traumatisme` for rheumatology and trauma medications.

**How many products can I scrape?**
Farmacia Tei has over 50,000 products. The default limit is 100 products per run, configurable up to 10,000. For larger volumes, run multiple searches with different keywords or categories.

**What product categories are available?**
Farmacia Tei covers: OTC medications, supplements and vitamins, dermatological cosmetics, personal care, baby care, diet and wellness, sexual health, veterinary products, and medical devices.

### Limitations

- The site renders product listings dynamically. The actor scrolls the page to trigger lazy loading, but some products may not load on very large result sets.
- Product descriptions are extracted from detail pages when available. Listing page extraction may not include descriptions.
- Prices are in RON (Romanian lei). The actor does not convert to other currencies.
- Categories and product structures may change as Farmacia Tei updates their website.
- Not all products have discount information -- only products currently on promotion show original prices.

### Related European pharmacy and health 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

### Your feedback

Need specific product categories, deeper medical data extraction, 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., 'ibuprofen', 'vitamina C', 'crema de fata'). Uses Farmacia Tei's search page.

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

A Farmacia Tei category page URL to scrape. Example: https://comenzi.farmaciatei.ro/medicamente-otc/reumatologie-si-traumatisme. If empty and no search query, a default search will be used.

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

Maximum number of products to return.

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

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

## Actor input object example

```json
{
  "searchQuery": "ibuprofen",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RO"
  }
}
```

# 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": "ibuprofen",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RO"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/farmacia-tei-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": "ibuprofen",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RO",
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Farmacia Tei Scraper - Romanian Pharmacy Products",
        "description": "Scrape products, prices, discounts, and availability from Farmacia Tei (comenzi.farmaciatei.ro) — Romania's largest online pharmacy with 50,000+ products. Extract OTC medications, supplements, cosmetics, and health products. No login needed.",
        "version": "0.1",
        "x-build-id": "IJEbXPFTDCbguHgZU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~farmacia-tei-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-farmacia-tei-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~farmacia-tei-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-farmacia-tei-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~farmacia-tei-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-farmacia-tei-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., 'ibuprofen', 'vitamina C', 'crema de fata'). Uses Farmacia Tei's search page."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A Farmacia Tei category page URL to scrape. Example: https://comenzi.farmaciatei.ro/medicamente-otc/reumatologie-si-traumatisme. If empty and no search query, a default search will be used."
                    },
                    "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 with Romania country 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
