# Practo Doctor Scraper (`khadinakbar/practo-doctor-scraper`) Actor

Scrape Practo.com doctors by specialty + city or URL — name, qualifications, experience, fee, recommendation %, reviews, clinic address, services & geo. HTTP-only, no login. MCP-ready.

- **URL**: https://apify.com/khadinakbar/practo-doctor-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 doctor scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Practo Doctor Scraper

Scrape doctor data from **[Practo.com](https://www.practo.com)** — India's largest doctor-discovery and appointment platform — by **specialty + city** or by pasting **listing / profile URLs**. Returns clean, structured records: name, qualifications (degree + college + year), years of experience, consultation fee, recommendation %, review counts, clinic name + full address, geo-coordinates, services, and more. Optional one-click **profile deep-enrich** adds the full bio, every service, medical-council registrations, memberships, languages, awards, and work history.

HTTP-only (no headless browser), fast, and **MCP-ready** for AI agents.

### What you get

| Field | Example | Notes |
|---|---|---|
| `doctorName` | `Dr. Shireen Furtado` | |
| `specialization` | `Dermatologist` | primary specialty |
| `specialties` | `["Dermatologist","Cosmetologist"]` | all tagged specialties |
| `experienceYears` | `21` | |
| `qualifications` | `[{degree:"MBBS", college:"KIMS", year:2006}]` | degree + college + year |
| `consultationFee` | `1200` | in `feeCurrency` (INR) |
| `recommendationPercent` | `93` | patient recommendation % |
| `patientsCount` / `reviewsCount` | `157` / `157` | |
| `clinicName` / `clinicType` | `Aster CMI Hospital` | |
| `addressLine` / `locality` / `city` / `zipcode` | `Hebbal, Bangalore` | |
| `latitude` / `longitude` | `13.05`, `77.59` | map-ready geo |
| `popularServices` / `servicesCount` | `18` | |
| `isPractoPrime` | `false` | |
| `nextAvailable` | `2026-07-01T04:30:00Z` | next slot (ISO 8601) |
| `imageUrl` / `profileUrl` | `https://…` | |
| `summary` | short bio snippet | |

**Deep-enrich fields** (when `enrichDetails` is on): `about`, `specialistYears`, `registrationVerified`, `allServices` (up to 80), `procedures`, `registrations` (number + council + year), `memberships`, `languages`, `awards`, `experiences`.

### When to use it

- **Healthcare lead generation** — build targeted doctor/clinic lists by city and specialty.
- **Medical recruiting** — source specialists with verified qualifications and experience.
- **Pharma & medical-device outreach** — segment doctors by specialty, location, and patient volume.
- **Market & competitive research** — fee benchmarks, clinic density, specialty coverage by city.
- **Directory / aggregator products** — seed a doctor directory with structured, geo-tagged records.

**Do not use this for** patient personal data, booking automation, or any private/login-gated content — this actor only reads **public** doctor listing and profile pages.

### Pricing

Pay-per-event (you also pay standard Apify platform usage):

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| **Doctor scraped** | **$0.005** per doctor record |
| Profile deep-enrich | $0.003 per doctor (only when `enrichDetails` is on) |

A typical 50-doctor run costs about **$0.25** (listing only), or **$0.65** with deep-enrich. The actor prints an upfront cost cap in the log and never charges past your `maxItems`.

### Input

| Field | Type | Description |
|---|---|---|
| `specialty` | string | e.g. `Dermatologist`, `Dentist`, `Gynecologist`. Used with `city`. |
| `city` | string | e.g. `Bangalore`, `Delhi`, `Mumbai`. Used with `specialty`. |
| `startUrls` | array | Practo listing or `/doctor/` profile URLs. Takes priority over specialty+city. |
| `maxItems` | integer | Max doctors to return (default `50`). Auto-paginates. |
| `enrichDetails` | boolean | Visit each profile for the full bio/services/registrations (default `false`). |
| `proxyConfiguration` | object | Defaults to Apify **RESIDENTIAL**, country **IN** (required — see below). |

#### Example input — search

```json
{
  "specialty": "Dermatologist",
  "city": "Bangalore",
  "maxItems": 50
}
````

#### Example input — URLs + deep-enrich

```json
{
  "startUrls": [
    "https://www.practo.com/delhi/dentist",
    "https://www.practo.com/bangalore/doctor/dr-shireen-furtado"
  ],
  "maxItems": 100,
  "enrichDetails": true
}
```

### Run via API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~practo-doctor-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"specialty":"Cardiologist","city":"Mumbai","maxItems":50}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/practo-doctor-scraper').call({
  specialty: 'Pediatrician',
  city: 'Hyderabad',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### MCP / AI agents

Exposed in the Apify MCP server as `apify--practo-doctor-scraper`. Give an agent a specialty + city (or a Practo URL) and it returns structured doctor JSON — ideal for healthcare research and lead-gen agents. Add `?tools=khadinakbar/practo-doctor-scraper` to your MCP client URL.

### Why this scraper

- **HTTP-only** — no headless browser, so it's faster and cheaper than browser-automation alternatives.
- **Richer data** — qualifications with college + year, recommendation %, geo-coordinates, and a deep-enrich mode that returns council registrations, memberships, awards, and full work history.
- **Two input modes** — keyword search *or* direct URLs.
- **Honest behavior** — soft-fails on bad input, paginates automatically, respects your `maxItems` cap, and reports an upfront cost estimate.

### Notes & reliability

Practo serves a challenge wall to datacenter IPs, so the actor uses **Apify Residential proxies pinned to India (`IN`)** by default. Keep this setting unless you have a proxy pool you know clears Practo. Practo occasionally A/B-tests its page markup; the actor extracts from the page's embedded application state with a structured-data (JSON-LD) fallback for resilience.

### FAQ

**Which cities and specialties are supported?** Any city/specialty combination that exists on Practo (most Indian metros and tier-2 cities; dozens of specialties). If a combination has no doctors, the run finishes cleanly with an empty dataset.

**How many doctors can I get per search?** As many as Practo lists for that specialty + city, paginated automatically up to your `maxItems`.

**Do I need login or cookies?** No. Only public pages are read.

**Can I get email/phone?** Practo does not expose doctor emails/phones publicly, so those are not returned. You get clinic name, full address, geo, fee, and profile URL.

**Is `enrichDetails` worth it?** Use it when you need the full bio, complete service list, council registration numbers, memberships, languages, and awards. Skip it for fast, cheap listing-only pulls.

### Legal & compliance

This actor collects only **publicly available** information from Practo.com. It does not bypass logins or access private data. You are responsible for using the scraped data in compliance with Practo's Terms of Service, applicable data-protection laws (including India's DPDP Act and the GDPR where relevant), and any professional/medical data regulations in your jurisdiction. Do not use this data for spam, harassment, or unlawful purposes. This actor is not affiliated with or endorsed by Practo.

# Actor input Schema

## `specialty` (type: `string`):

Doctor specialty or keyword to search on Practo, e.g. 'Dermatologist', 'Dentist', 'Gynecologist'. Combined with 'city' to build the listing URL (city/specialty). Ignored when 'startUrls' is provided. NOT a doctor name — use a specialty or treatment term.

## `city` (type: `string`):

Indian city to search in, e.g. 'Bangalore', 'Delhi', 'Mumbai', 'Hyderabad', 'Chennai'. Combined with 'specialty' to build the listing URL. Ignored when 'startUrls' is provided. Use the city name only, not a full address.

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

Practo listing URLs (e.g. https://www.practo.com/bangalore/dermatologist) or individual doctor profile URLs (.../doctor/...). When provided, these take priority over specialty+city. Each item is a plain URL string on practo.com. Leave empty to use the specialty+city search instead.

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

Maximum number of doctor records to return across all pages. The actor paginates automatically until this cap or the result set is exhausted. Defaults to 50. Set lower for cheap test runs; the cap is enforced before any charge.

## `enrichDetails` (type: `boolean`):

When enabled, the actor visits each doctor's profile page to add fields not present on listings (full about text, all services, registrations, memberships). Slower and bills an extra detail-enriched event per doctor. Leave off for fast listing-only scraping. Defaults to false.

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

Proxy used to reach Practo. Practo blocks datacenter IPs with a challenge wall, so Apify RESIDENTIAL with countryCode 'IN' is required and used by default. Override only if you know your pool clears Practo. Do not disable proxy.

## Actor input object example

```json
{
  "specialty": "Dermatologist",
  "city": "Bangalore",
  "startUrls": [],
  "maxItems": 50,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `doctors` (type: `string`):

Dataset of scraped Practo doctor records (name, qualifications, fee, clinic, location, services).

# 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 = {
    "specialty": "Dermatologist",
    "city": "Bangalore",
    "startUrls": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/practo-doctor-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 = {
    "specialty": "Dermatologist",
    "city": "Bangalore",
    "startUrls": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/practo-doctor-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 '{
  "specialty": "Dermatologist",
  "city": "Bangalore",
  "startUrls": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call khadinakbar/practo-doctor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Practo Doctor Scraper",
        "description": "Scrape Practo.com doctors by specialty + city or URL — name, qualifications, experience, fee, recommendation %, reviews, clinic address, services & geo. HTTP-only, no login. MCP-ready.",
        "version": "1.0",
        "x-build-id": "IVUuEBPxlEoydzKAU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~practo-doctor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-practo-doctor-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/khadinakbar~practo-doctor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-practo-doctor-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/khadinakbar~practo-doctor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-practo-doctor-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": {
                    "specialty": {
                        "title": "Specialty / keyword",
                        "type": "string",
                        "description": "Doctor specialty or keyword to search on Practo, e.g. 'Dermatologist', 'Dentist', 'Gynecologist'. Combined with 'city' to build the listing URL (city/specialty). Ignored when 'startUrls' is provided. NOT a doctor name — use a specialty or treatment term."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Indian city to search in, e.g. 'Bangalore', 'Delhi', 'Mumbai', 'Hyderabad', 'Chennai'. Combined with 'specialty' to build the listing URL. Ignored when 'startUrls' is provided. Use the city name only, not a full address."
                    },
                    "startUrls": {
                        "title": "Practo URLs (optional)",
                        "type": "array",
                        "description": "Practo listing URLs (e.g. https://www.practo.com/bangalore/dermatologist) or individual doctor profile URLs (.../doctor/...). When provided, these take priority over specialty+city. Each item is a plain URL string on practo.com. Leave empty to use the specialty+city search instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max doctors",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of doctor records to return across all pages. The actor paginates automatically until this cap or the result set is exhausted. Defaults to 50. Set lower for cheap test runs; the cap is enforced before any charge.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Deep-enrich from profile pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each doctor's profile page to add fields not present on listings (full about text, all services, registrations, memberships). Slower and bills an extra detail-enriched event per doctor. Leave off for fast listing-only scraping. Defaults to false.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach Practo. Practo blocks datacenter IPs with a challenge wall, so Apify RESIDENTIAL with countryCode 'IN' is required and used by default. Override only if you know your pool clears Practo. Do not disable proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
