# Doctoralia Mexico Scraper (`automation-lab/doctoralia-mexico-scraper`) Actor

Scrape public Doctoralia Mexico doctors and clinics by specialty and city. Export names, profiles, specialties, ratings, addresses, services, and prices.

- **URL**: https://apify.com/automation-lab/doctoralia-mexico-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Doctoralia Mexico Scraper

Export public Doctoralia Mexico doctor and clinic search results into a clean dataset for healthcare lead generation, market research, recruiting, and local SEO workflows.

### What does Doctoralia Mexico Scraper do?

Doctoralia Mexico Scraper collects public records from `doctoralia.com.mx` search result pages.

It searches by specialty or service keyword and Mexican location, then saves structured fields such as name, profile URL, specialties, rating, review count, address, service, visible price, image URL, and source search metadata.

The actor is designed for repeatable exports, not one-off copy and paste.

### Who is it for?

Healthcare marketing agencies can build prospect lists by specialty and city.

Clinic software vendors can identify practices that may need booking, CRM, or patient communication tools.

Recruiters can map specialist supply in different Mexican markets.

Insurance, pharma, and medical device teams can monitor publicly listed provider coverage.

Local SEO teams can audit competitors and categories across cities.

### Why use this actor?

Doctoralia search pages are useful but manual browsing is slow.

This actor turns public listings into rows you can filter, export, enrich, and send into your existing tools.

It also stores the source search URL, page, position, and scrape timestamp so every record is traceable.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Doctor or clinic name shown by Doctoralia |
| `profileUrl` | Public Doctoralia profile URL |
| `specialties` | Medical specialties from structured search data |
| `rating` | Public rating when available |
| `reviewCount` | Number of reviews when available |
| `streetAddress` | Visible address line |
| `city` | City from the postal address |
| `region` | State or region code/name |
| `serviceName` | Visible service or appointment type |
| `price` | Visible price when Doctoralia exposes one |
| `priceCurrency` | Price currency, usually MXN |
| `imageUrl` | Profile image URL when available |
| `searchTerm` | Search keyword that produced the record |
| `location` | Location input that produced the record |
| `sourceUrl` | Search result page URL |
| `page` | Search page number |
| `position` | Position on the source page |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Doctoralia Mexico?

The actor uses pay-per-event pricing.

You pay a $0.005 start event for each run and a tiered per-result event for records extracted.

Current per-result pricing is: FREE $0.00115, BRONZE $0.001, SILVER $0.00078, GOLD $0.0006, PLATINUM $0.0004, DIAMOND $0.00028.

Keep your first run small with the default prefill, review the output, then increase `maxResults` and `maxPages` for larger exports.

### How to use it

1. Open the actor on Apify.
2. Enter one or more search terms such as `dentista`, `cardiólogo`, or `dermatólogo`.
3. Enter one or more Mexican locations such as `Ciudad de México`, `Guadalajara`, or `Monterrey`.
4. Set `maxResults` to the number of records you want.
5. Optionally enable profile visits for extra profile metadata.
6. Start the run.
7. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Input settings

#### Search terms

Use Spanish specialty or service terms that work on Doctoralia Mexico.

Examples:

- `dentista`
- `cardiólogo`
- `dermatólogo`
- `psicólogo`
- `ginecólogo`

#### Locations

Use Mexican cities, states, or local areas.

Examples:

- `Ciudad de México`
- `Guadalajara`
- `Monterrey`
- `Puebla`
- `Querétaro`

#### Maximum doctors / clinics

This is the global cap across all search term and location combinations.

If you enter two terms and two locations with `maxResults` set to 100, the actor stops once it has saved 100 unique profile URLs.

#### Maximum pages per search

This prevents an accidental crawl of hundreds of pages.

Increase it when you need deeper coverage for large specialties and cities.

#### Visit profile pages

Leave this disabled for fast search exports.

Enable it when you want profile title and meta description fields from each public Doctoralia profile page.

### Example input

```json
{
  "searchTerms": ["dentista"],
  "locations": ["Ciudad de México"],
  "maxResults": 20,
  "maxPages": 2,
  "includeProfiles": false,
  "maxRequestRetries": 3
}
````

### Example output

```json
{
  "name": "Dr. Pedro Pacheco Vargas",
  "profileUrl": "https://www.doctoralia.com.mx/pedro-pacheco-vargas/dentista-odontologo/ciudad-de-mexico",
  "specialties": ["Dentista - Odontólogo"],
  "rating": 5,
  "reviewCount": 219,
  "streetAddress": "Zacatecas 35 Departamento 202)",
  "city": "Ciudad de México",
  "region": "CDMX",
  "serviceName": "Primera visita Odontología",
  "priceCurrency": "MXN",
  "searchTerm": "dentista",
  "location": "Ciudad de México",
  "page": 1,
  "position": 1
}
```

### Tips for better results

Use specific specialty names when possible.

Run one city first to confirm the keyword produces useful records.

Use multiple locations when you want a market comparison.

Keep `includeProfiles` off for large first-pass exports.

Deduplicate downstream by `profileUrl` or `doctoraliaSlug`.

### Integrations

Send the dataset to Google Sheets for manual review.

Connect it to a CRM to create healthcare prospect records.

Use webhooks to trigger enrichment after each successful run.

Feed records to a data warehouse for regional coverage analysis.

Combine with other Apify actors for email discovery, website crawling, or company enrichment where legally appropriate.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/doctoralia-mexico-scraper').call({
  searchTerms: ['dentista'],
  locations: ['Ciudad de México'],
  maxResults: 20,
  maxPages: 2
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/doctoralia-mexico-scraper').call(run_input={
    'searchTerms': ['dentista'],
    'locations': ['Ciudad de México'],
    'maxResults': 20,
    'maxPages': 2,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~doctoralia-mexico-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["dentista"],"locations":["Ciudad de México"],"maxResults":20,"maxPages":2}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/doctoralia-mexico-scraper
```

Claude Code setup:

```bash
claude mcp add apify-doctoralia-mexico "https://mcp.apify.com/?tools=automation-lab/doctoralia-mexico-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-doctoralia-mexico": {
      "url": "https://mcp.apify.com/?tools=automation-lab/doctoralia-mexico-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 dentists in Ciudad de México on Doctoralia and summarize the top specialties."
- "Export dermatologists in Guadalajara and group them by review count."
- "Run the Doctoralia Mexico scraper for cardiologists in Monterrey and prepare a CSV."

### Data quality notes

The actor extracts public structured data from search result pages.

Some fields are optional because Doctoralia does not expose every value for every record.

Prices may be missing for doctors or clinics that do not show a visible price.

Ratings and review counts are included when present in the structured data.

### Limitations

The actor does not log in.

It does not bypass paywalls or private patient data.

It does not guarantee phone numbers or emails because those are not consistently present in public search JSON-LD.

Search coverage depends on Doctoralia's own result ordering and availability.

### Troubleshooting

#### I received fewer records than requested

The search term and location may have fewer public results than your limit, or `maxPages` may be too low.

Increase `maxPages` or try a broader specialty.

#### Some prices are empty

Doctoralia only exposes prices for some services and profiles.

Empty prices mean the source page did not provide a structured visible price for that record.

#### Profile fields are empty

Enable `includeProfiles` to fetch profile pages.

For faster runs, the default search-only mode leaves profile metadata empty.

### Legality

This actor is intended to collect publicly available information from Doctoralia Mexico.

You are responsible for using the data in line with applicable laws, platform terms, privacy rules, and outreach regulations.

Avoid spam, sensitive profiling, or unlawful processing of personal data.

### Related scrapers

Explore related Apify actors from automation-lab:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/business-leads-scraper
- https://apify.com/automation-lab/website-contact-scraper

### Changelog

Initial version extracts Doctoralia Mexico search results using public structured data.

### Support

If a run fails or returns unexpected data, share the run URL and input with support so the issue can be reproduced.

### Responsible use

Use conservative limits for testing.

Respect Doctoralia and the people listed on the site.

Store only what you need for your legitimate workflow.

### FAQ

#### Can I search multiple specialties at once?

Yes. Add multiple values to `searchTerms`.

#### Can I search multiple cities at once?

Yes. Add multiple values to `locations`.

#### Is this a browser actor?

No. It is an HTTP actor built for speed and lower compute cost.

#### Does it scrape private patient information?

No. It only extracts public listing/profile metadata.

#### What is the best dedupe key?

Use `profileUrl` or `doctoraliaSlug`.

# Actor input Schema

## `searchTerms` (type: `array`):

Medical specialties, services, or keywords to search on Doctoralia Mexico.

## `locations` (type: `array`):

Mexican city, state, or area names used in Doctoralia search.

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

Maximum number of Doctoralia records to save across all search term and location combinations.

## `maxPages` (type: `integer`):

Maximum number of search result pages to visit for each term/location pair.

## `includeProfiles` (type: `boolean`):

Open each public Doctoralia profile page to add profile title and meta description. Leave off for faster, cheaper search exports.

## `maxRequestRetries` (type: `integer`):

Retry attempts for temporary network or upstream errors.

## Actor input object example

```json
{
  "searchTerms": [
    "dentista"
  ],
  "locations": [
    "Ciudad de México"
  ],
  "maxResults": 20,
  "maxPages": 2,
  "includeProfiles": false,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "dentista"
    ],
    "locations": [
        "Ciudad de México"
    ],
    "maxResults": 20,
    "maxPages": 2,
    "includeProfiles": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/doctoralia-mexico-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 = {
    "searchTerms": ["dentista"],
    "locations": ["Ciudad de México"],
    "maxResults": 20,
    "maxPages": 2,
    "includeProfiles": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/doctoralia-mexico-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 '{
  "searchTerms": [
    "dentista"
  ],
  "locations": [
    "Ciudad de México"
  ],
  "maxResults": 20,
  "maxPages": 2,
  "includeProfiles": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/doctoralia-mexico-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doctoralia Mexico Scraper",
        "description": "Scrape public Doctoralia Mexico doctors and clinics by specialty and city. Export names, profiles, specialties, ratings, addresses, services, and prices.",
        "version": "0.1",
        "x-build-id": "QQxUhZx0dG6FKWRJQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~doctoralia-mexico-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-doctoralia-mexico-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/automation-lab~doctoralia-mexico-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-doctoralia-mexico-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/automation-lab~doctoralia-mexico-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-doctoralia-mexico-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Medical specialties, services, or keywords to search on Doctoralia Mexico.",
                        "default": [
                            "dentista"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Mexican city, state, or area names used in Doctoralia search.",
                        "default": [
                            "Ciudad de México"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum doctors / clinics",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of Doctoralia records to save across all search term and location combinations.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of search result pages to visit for each term/location pair.",
                        "default": 10
                    },
                    "includeProfiles": {
                        "title": "Visit profile pages",
                        "type": "boolean",
                        "description": "Open each public Doctoralia profile page to add profile title and meta description. Leave off for faster, cheaper search exports.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for temporary network or upstream errors.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
