# Petco Store Details Scraper - Locations, Hours & Contact Info (`datacach/petco-store-details-scraper`) Actor

Scrape detailed Petco store data from any store URL: address, phone number, opening hours, GPS coordinates, price range, store photo, and in-store services like Grooming, Dog Training, Vet Clinic and Aquatics. Pair with Petco Store Links Scraper for full nationwide coverage.

- **URL**: https://apify.com/datacach/petco-store-details-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 stores

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/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

## Petco Store Details Scraper

**Extract Petco store data** — address, phone number, opening hours, GPS coordinates, price range, and in-store services — straight from [stores.petco.com](https://stores.petco.com/) with no coding required. Feed it a list of Petco store page URLs (or pair it with the **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** Actor for full nationwide coverage) and get clean, structured **JSON, CSV, or Excel** data back in seconds.

Built to run on the **Apify platform**, so every run comes with a ready-to-use **API**, **scheduling**, **monitoring**, and one-click **integrations** with Zapier, Make, Google Sheets, and dozens of other tools — no infrastructure to maintain.

### What is Petco Store Details Scraper?

Petco Store Details Scraper is a Petco **store data scraper** that turns a list of Petco store page URLs into a structured dataset of **store locations, contact info, hours, and services**. It reads the `PetStore` JSON-LD structured data that Petco publishes on every store page — the same data Petco feeds to search engines — so the extracted fields are accurate and directly sourced from the retailer.

It's designed to be the second half of a two-step pipeline: run the **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** Actor (or supply your own list) to get store URLs, then run this Actor to enrich each URL with **full store metadata**.

### What can Petco Store Details Scraper do?

- 🏬 **Extract full store profiles** — name, street address, city, state, ZIP/postal code, country, and store ID for every Petco location
- 📞 **Pull contact details** — store phone number and department-level phone numbers
- 📍 **Return precise GPS coordinates** — latitude/longitude for both the store and each in-store service
- 🕒 **Capture opening hours** — raw structured hours for the store and each department
- 🛁 **List in-store services** — Grooming, Dog Training, Vaccination/Vet Clinic, Aquatics, and more, each with its own hours, phone, and coordinates
- 💲 **Include price range and store photo** — plus the store description as published by Petco
- ⚡ **Run fast, concurrent extractions** — configurable concurrency (1–20 stores in parallel)
- 📤 **Export to JSON, CSV, Excel, HTML, or XML** — download straight from the Output tab or pull via API
- 🔌 **Automate with the Apify API** — trigger runs, fetch results, and integrate with your own systems
- ⏰ **Schedule recurring runs** — keep store data fresh automatically
- 📊 **Monitor every run** — get alerted on failures or anomalies via Apify's built-in monitoring
- 🔗 **Chain with other Actors** — pipe URLs straight from [Petco Store Links](https://apify.com/datacach/petco-store-links-scraper), or push results into a database or CRM via integrations

### What data does Petco Store Details Scraper extract?

| Field | Description |
|---|---|
| `name` | Store display name (e.g. "Petco Pet Store in Fairbanks") |
| `store_id` | Petco's internal store ID |
| `street`, `city`, `state`, `zipcode`, `country` | Full store address |
| `phone` | Store phone number |
| `latitude`, `longitude` | Store GPS coordinates |
| `hours_raw` | Structured opening hours for the store |
| `description` | Store description as published by Petco |
| `price_range` | Petco's price-range indicator (e.g. `$$`) |
| `image_url` | URL of the store's photo |
| `services` | Array of in-store services (Grooming, Training, Vet Clinic, Aquatics, etc.), each with its own `name`, `phone`, `hours_raw`, `latitude`, and `longitude` |
| `url` | The source store page URL |
| `extraction_datetime` | UTC timestamp (ISO 8601) of when the item was extracted |
| `extraction_date` | Extraction date in `mm-dd-yyyy` format |

<!-- TODO: screenshot of a sample dataset table from the Output tab -->

### How do I use Petco Store Details Scraper to get store data from stores.petco.com?

1. **Get store URLs.** Run the **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** Actor to generate a nationwide list of Petco store page URLs, or gather your own list manually.
2. **Open Petco Store Details Scraper** on the Apify platform and go to the **Input** tab.
3. **Paste the URLs** into the `links` field (one per line or as a JSON array).
4. **Optionally set `maxConcurrency`** (default `5`, max `20`) to control how many stores are fetched in parallel.
5. Click **Start** and watch the run progress in real time.
6. Once finished, open the **Output** tab and **export your data** as JSON, CSV, Excel, HTML, or XML — or pull it programmatically via the Apify API.

<!-- TODO: embed demo video or GIF walkthrough here, e.g. https://www.youtube.com/watch?v=YOUR_VIDEO_ID -->

### Input

Petco Store Details Scraper takes two simple inputs:

- **Store links** (`links`) — an array of Petco store page URLs to extract metadata from, typically the output of the **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** Actor. On the free plan, only the first 5 links are processed per run.
- **Max concurrency** (`maxConcurrency`) — the maximum number of stores fetched in parallel (1–20, default 5). Raise it for faster runs on larger lists, or lower it to go easier on rate limits.

<!-- TODO: screenshot of the Input tab / input schema form -->

```json
{
    "links": [
        "https://stores.petco.com/ak/anchorage/pet-supplies-anchorage-ak-1215.html",
        "https://stores.petco.com/ak/fairbanks/pet-supplies-fairbanks-ak-1147.html"
    ],
    "maxConcurrency": 5
}
````

### Free vs paid Apify account: what's the difference?

Petco Store Details Scraper runs the same code for everyone — the only difference between a **free** and a **paid (premium)** Apify account is how many links you can process **per run**:

| | Free account | Paid account |
|---|---|---|
| Links processed per run | First **5** links only (extras are silently ignored) | **Unlimited** — process your entire `links` list |
| Extraction fields returned | Full — same address, hours, services, and coordinates data | Full — identical output, no fields are held back |
| Concurrency (`maxConcurrency`) | Up to 20, same as paid | Up to 20, same as paid |
| Scheduling, API access, monitoring, integrations | ✅ Available (standard Apify platform features) | ✅ Available (standard Apify platform features) |

In short: a free account is great for **testing the Actor** on a handful of stores, while a paid account is required to **scrape your full store list** in one run — for example, all Petco locations returned by the **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** Actor. If you're on the free plan and pass more than 5 links, the Actor logs a warning and trims the list automatically instead of failing the run.

### Output example

Each dataset item is one Petco store, with full contact info, hours, and services:

```json
{
    "url": "https://stores.petco.com/ak/fairbanks/pet-supplies-fairbanks-ak-1147.html",
    "name": "Petco Pet Store in Fairbanks",
    "store_id": "1147",
    "street": "417 Merhar Ave",
    "city": "Fairbanks",
    "state": "AK",
    "zipcode": "99701",
    "country": "US",
    "phone": "+19072571507",
    "latitude": 64.85676350021093,
    "longitude": -147.70108261698056,
    "hours_raw": {
        "openingHours": ["Mo,Tu,We,Th,Fr,Sa,Su 09:00-20:00"]
    },
    "description": "Petco pet store in Fairbanks offers pet supplies, nutrition and services including Full-Service Grooming, Dog Training, Vaccination Clinic, Aquatics Department in one convenient location.",
    "price_range": "$$",
    "image_url": "https://a.mktgcdn.com/p/VfUabkyQ_G1-aJAJpuH8lVfDxZz6Rx9oQZoxusNKdqs/1359x1086.jpg",
    "services": [
        {
            "name": "Dog Grooming",
            "phone": "+19072571507",
            "hours_raw": { "openingHours": ["Mo,Tu,We,Th,Fr,Sa,Su 08:00-18:00"] },
            "latitude": 64.856752181099,
            "longitude": -147.7010179196434
        },
        {
            "name": "Dog Training",
            "phone": "+19072571507",
            "hours_raw": { "openingHours": ["Mo,Tu,We,Th,Fr,Sa,Su 09:00-20:00"] },
            "latitude": 64.85681660530861,
            "longitude": -147.7009398916657
        }
    ],
    "extraction_datetime": "2026-07-24T06:17:13.578588+00:00",
    "extraction_date": "07-24-2026"
}
```

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**, or fetch it programmatically via the Apify API.

### Use cases

- 🗺️ **Store locator and mapping apps** — power a Petco store map or "find a store near me" feature with fresh address and geolocation data
- 📈 **Retail market research** — analyze Petco's store footprint, density, and services mix by state or region
- 🏢 **Competitive intelligence** — track Petco's service offerings (grooming, training, vet clinics) across locations
- 📇 **Lead generation & local outreach** — build a contact list of Petco store phone numbers by region
- 🔄 **Data enrichment pipelines** — enrich an existing store-location dataset with hours, services, and coordinates
- 🧾 **Business directory / aggregator sites** — populate pet-store listings with accurate, up-to-date details

### Petco-related Actors

| Actor | What it does |
|---|---|
| **[Petco Store Links](https://apify.com/datacach/petco-store-links-scraper)** | Crawls the Petco sitemap to produce the full list of Petco store page URLs — feed its output directly into this Actor |
|  | |

### FAQ

#### Is it legal to scrape Petco store data?

Yes. This Actor only extracts **publicly available data** from the `PetStore` JSON-LD structured data that Petco itself publishes on every store page for search engines. Scraping publicly accessible data is generally legal, but you're responsible for ensuring your use complies with Petco's Terms of Service and applicable laws in your jurisdiction, especially if you plan to republish the data.

#### Does Petco Store Details Scraper have an API?

Yes. Every Apify Actor, including this one, is automatically exposed as an **API endpoint**. You can start runs, check status, and download results programmatically — see the **API** tab on the Actor's page for ready-to-use code snippets in multiple languages.

#### How many stores can I scrape on the free plan?

Free Apify accounts are limited to the **first 5 links** per run. See [Free vs paid Apify account](#free-vs-paid-apify-account-whats-the-difference) above for the full comparison, or upgrade to a paid Apify plan to process unlimited store links.

#### What happens if a store link is blocked or fails?

Links that are blocked by anti-bot protection or fail to load are **skipped and logged**, not silently dropped — you'll see a summary of successful, blocked, and failed links in the run log. The run only fails if *no* link succeeds.

#### What format is `hours_raw` in?

`hours_raw` mirrors the raw `openingHours` array from Petco's structured data (e.g. `"Mo,Tu,We,Th,Fr,Sa,Su 09:00-20:00"`), following the [schema.org opening hours specification](https://schema.org/openingHours). Parse it yourself if you need normalized hour ranges per weekday.

### Support

Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab in Apify Console. Need Petco data in a different shape, a custom crawl, or a fully managed integration? Reach out — custom scraping solutions are available on request.

# Actor input Schema

## `links` (type: `array`):

Petco store page URLs to extract metadata from — typically the output of the Petco Store Links Actor. Free plan processes only the first 5 links.

## `maxConcurrency` (type: `integer`):

Maximum number of stores fetched in parallel (1-20).

## Actor input object example

```json
{
  "links": [
    "https://stores.petco.com/ak/anchorage/pet-supplies-anchorage-ak-1215.html"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

## `dataset` (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 = {
    "links": [
        "https://stores.petco.com/ak/anchorage/pet-supplies-anchorage-ak-1215.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/petco-store-details-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 = { "links": ["https://stores.petco.com/ak/anchorage/pet-supplies-anchorage-ak-1215.html"] }

# Run the Actor and wait for it to finish
run = client.actor("datacach/petco-store-details-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 '{
  "links": [
    "https://stores.petco.com/ak/anchorage/pet-supplies-anchorage-ak-1215.html"
  ]
}' |
apify call datacach/petco-store-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Petco Store Details Scraper - Locations, Hours & Contact Info",
        "description": "Scrape detailed Petco store data from any store URL: address, phone number, opening hours, GPS coordinates, price range, store photo, and in-store services like Grooming, Dog Training, Vet Clinic and Aquatics. Pair with Petco Store Links Scraper for full nationwide coverage.",
        "version": "0.0",
        "x-build-id": "RXuHIHHhgVkiGQtFM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~petco-store-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-petco-store-details-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/datacach~petco-store-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datacach-petco-store-details-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/datacach~petco-store-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-petco-store-details-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",
                "required": [
                    "links"
                ],
                "properties": {
                    "links": {
                        "title": "Store links",
                        "type": "array",
                        "description": "Petco store page URLs to extract metadata from — typically the output of the Petco Store Links Actor. Free plan processes only the first 5 links.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of stores fetched in parallel (1-20).",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
