# Dollar Tree Store Details Scraper (`datacach/dollar-tree-store-details-scraper`) Actor

Extract complete Dollar Tree store details — address, phone number, GPS coordinates, and opening hours — for any US Dollar Tree location. Pair with the Dollar Tree Store Locator Scraper to turn a list of store URLs into structured, ready-to-use data.

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

## Pricing

from $0.50 / 1,000 processed links

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

## Dollar Tree Store Details Scraper

**Extract complete Dollar Tree store details** — address, phone number, GPS coordinates, opening hours, amenities, and SEO metadata — from any [Dollar Tree store locator](https://locations.dollartree.com/) page URL. Feed it a list of store links (typically the output of the [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper)) and get back clean, structured **JSON data** ready for mapping, lead generation, competitive research, or your own database.

No coding required to run it, but it's built for developers too: call it via the **Apify API**, schedule recurring runs, and pipe results straight into your stack through **Zapier**, **Make**, or a webhook.

### 🌳 What is Dollar Tree Store Details Scraper?

Dollar Tree Store Details Scraper is an Apify Actor that turns a list of Dollar Tree store page URLs into a **structured dataset** of everything published on each store's public page. It's the companion tool to the [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper) (which discovers store URLs by location) — chain the two together and go from "every Dollar Tree in a state" to a full, ready-to-use spreadsheet of store data in minutes.

### 🔍 What can Dollar Tree Store Details Scraper do?

- 📍 **Extract full store profiles** — name, street address, city, state, ZIP code, phone number, latitude/longitude, and raw opening hours for each store page you give it.
- 🏷️ **Pull store amenities and services** — EBT acceptance, frozen/refrigerated foods, snack zone, Hallmark greeting cards, BOPIS, and more, both as boolean flags and as a human-readable list.
- 🔗 **Grab the Google Maps business link** and SEO metadata (`meta_title`, `meta_description`, marketing description) straight from each store page.
- ⏱️ **Timestamp every record** with the exact extraction date and time (UTC), so you always know how fresh your data is.
- 🚦 **Skip blocked or failed links gracefully** — anti-bot blocks and fetch errors are logged and skipped instead of crashing the whole run.
- 📤 **Export in multiple formats** — download results as JSON, CSV, Excel, or HTML directly from the Output tab.
- 🔌 **Automate with the Apify API and SDK** — trigger runs programmatically, schedule recurring extractions, and integrate with Zapier, Make, or any webhook-based workflow.
- 📊 **Monitor every run** from the Apify Console — logs, stats, and dataset previews without touching a server.

### 🗂️ What data does Dollar Tree Store Details Scraper extract?

| Field | Description |
|---|---|
| `name` | Store brand name |
| `store_id` | Dollar Tree's internal store number |
| `street`, `city`, `state`, `zipcode` | Full store address |
| `phone` | Store phone number |
| `latitude`, `longitude` | GPS coordinates |
| `hours_raw` | Raw opening-hours object, as embedded in the store page |
| `geomodifier` | Store's local name modifier (e.g. area or shopping center name) |
| `description` | Store's marketing description |
| `meta_title`, `meta_description` | SEO title/description from the store page |
| `google_maps_url` | Direct link to the store's Google Business Profile |
| `has_ebt`, `has_frozen`, `has_snack`, `has_hallmark_greeting_cards`, `has_more_choices`, `has_bopis` | Boolean amenity/service flags |
| `amenities` | Same amenities as a human-readable list |
| `url` | The original store page URL that was scraped |
| `extraction_datetime`, `extraction_date` | UTC timestamp of when the record was extracted |

### 🚀 How do I scrape Dollar Tree store details?

1. Run the [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper) (or otherwise collect Dollar Tree store page URLs yourself).
2. Open this Actor's **Input** tab and paste your URLs into the `links` field.
3. Optionally adjust `maxConcurrency` to control how many stores are fetched in parallel (default: 5).
4. Click **Start**.
5. When the run finishes, open the **Output** tab and download your data as JSON, CSV, Excel, or HTML — or pull it programmatically via the **Apify API**.

<!-- TODO: embed a demo GIF or YouTube video walking through steps 1-5 -->

### ⚙️ Input

![Dollar Tree Store Details Scraper input example](https://github.com/BenjaminFloresV/public-datacach-apify-actors-media/blob/main/dollar-tree-store-details-scraper/input-example.png?raw=true)

This Actor takes two inputs:

- **Store page URLs** (`links`) — a list of Dollar Tree store page URLs to extract metadata from, e.g. `https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300`. This is a required field; it works best when populated with the output of the [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper). *(Free-plan runs process only the first 5 links.)*
- **Max concurrency** (`maxConcurrency`) — how many stores are fetched in parallel. Higher values finish faster but slightly increase the chance of anti-bot blocks. Default is 5, with a maximum of 20.

Example input:

```json
{
    "links": ["https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300"],
    "maxConcurrency": 5
}
````

### 🔓 Free vs. paid plan

|  | Free Apify account | Paid Apify account |
|---|---|---|
| Links processed per run | First **5 unique** links only | **All** links you submit — no cap |
| Store details, amenities, SEO metadata, timestamps | ✅ Full data | ✅ Full data |
| Max concurrency | Up to 20 | Up to 20 |

If you're on a free Apify account and submit more than 5 links, the Actor automatically keeps only the first 5 unique ones, logs a warning, and still completes the run successfully — just with a smaller dataset. **Upgrade your Apify plan** to remove this cap and process your entire list of store links in a single run.

### 📦 Output example

Each dataset item looks like this:

```json
{
    "url": "https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300",
    "name": "Dollar Tree",
    "store_id": "8553",
    "street": "7661 Highway 431, Ste 300",
    "city": "Albertville",
    "state": "AL",
    "zipcode": "35950",
    "phone": "(256) 559-3081",
    "latitude": 34.2345,
    "longitude": -86.1589,
    "hours_raw": { "monday": { "openIntervals": [{ "start": "09:00", "end": "21:00" }] } },
    "geomodifier": "Albertville BTS",
    "description": "From inspiring craft and party supplies to everyday essentials and beyond, Dollar Tree at Albertville, AL is your go-to for all things affordable! ...",
    "meta_title": "Dollar Tree Store at Albertville BTS in Albertville, AL",
    "meta_description": "Shop for groceries, household goods, toys, and more at your local Dollar Tree Store at Albertville BTS in Albertville, AL",
    "google_maps_url": "https://maps.google.com/?cid=12702145241973651821",
    "has_ebt": true,
    "has_frozen": true,
    "has_snack": true,
    "has_hallmark_greeting_cards": true,
    "has_more_choices": true,
    "has_bopis": false,
    "amenities": ["FROZEN/REFRIGERATED_FOODS", "SNACK_ZONE™", "GREETING_CARDS:_EXPRESSIONS_FROM_HALLMARK", "ACCEPTS_EBT", "NEW_ITEMS,_GREAT_VALUE"],
    "extraction_datetime": "2026-07-21T14:30:00.123456+00:00",
    "extraction_date": "07-21-2026"
}
```

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

### 💡 Use cases

- **Market research & site selection** — analyze Dollar Tree's store footprint, density, and amenities by state or region before opening a competing location.
- **Store locator apps** — power a "find your nearest Dollar Tree" feature with fresh address, phone, and geolocation data.
- **Lead generation** — build outreach lists for vendors, franchise consultants, or local advertisers targeting specific Dollar Tree stores.
- **Competitive intelligence** — track which amenities (EBT, BOPIS, frozen foods) are available at which locations over time.
- **Data enrichment** — merge structured Dollar Tree store data into a larger retail dataset or CRM.
- **SEO / local search audits** — pull each store's `meta_title` and `meta_description` to audit how Dollar Tree's local pages are optimized.

### 🔗 Dollar Tree-related Actors

| Actor | What it does |
|---|---|
| [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper) | Discovers Dollar Tree store page URLs by state, city, or ZIP — feed its output directly into this Actor to go from "every Dollar Tree in an area" to full store details. |
|  | |

### ❓ FAQ

#### Is it legal to scrape Dollar Tree store data?

This Actor only collects **publicly available data** from the same store pages the Dollar Tree website itself serves to any visitor's browser. That said, you're responsible for complying with Dollar Tree's Terms of Service and applicable law in your jurisdiction. Consult a legal professional if you plan to use the data commercially at scale.

#### Do I need Dollar Tree store page URLs before I can use this Actor?

Yes — this Actor extracts details from store pages you already have URLs for. Use the [Dollar Tree Store Locator Scraper](https://apify.com/datacach/dollar-tree-store-locator-scraper) first if you only know a state, city, or ZIP code and need to discover the store URLs.

#### Can I access the scraped Dollar Tree data via API?

Yes. Every Actor run and its dataset are available through the [Apify API](https://docs.apify.com/api/v2) and the [Apify SDK](https://docs.apify.com/sdk), so you can trigger runs and pull results directly into your own application or pipeline.

#### What happens if a store page is blocked or fails to load?

Blocked or failed links are logged and skipped — they don't stop the rest of the run. The run only fails if **every** link fails; otherwise you get results for every store that succeeded.

#### Is there a limit on how many stores I can scrape on the free plan?

Yes — free Apify accounts get the first 5 unique store links processed per run. Paid accounts have no cap and can process as many links as you submit in one go. See the [Free vs. paid plan](#-free-vs-paid-plan) section above for details.

#### Can I schedule this Actor to run automatically?

Yes. Use the Apify Console's built-in **Scheduler** to run this Actor on a recurring basis (e.g. weekly) to keep your Dollar Tree store dataset fresh.

### 🛟 Support

Found a bug or have a feature request? Open an issue on this Actor's **Issues** tab in Apify Console. Need a custom scraper or a modified version of this Actor for your specific use case? Reach out — custom development is available.

# Actor input Schema

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

Dollar Tree store page URLs to extract metadata from, e.g. <code>https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300</code> — typically the output of the Dollar Tree Store Links Actor. Free plan processes only the first 5 links.

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

Maximum number of stores fetched in parallel. Higher values finish faster but increase the chance of anti-bot blocks.

## Actor input object example

```json
{
  "links": [
    "https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300"
  ],
  "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://locations.dollartree.com/al/albertville/7661-highway-431-ste-300"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/dollar-tree-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://locations.dollartree.com/al/albertville/7661-highway-431-ste-300"] }

# Run the Actor and wait for it to finish
run = client.actor("datacach/dollar-tree-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://locations.dollartree.com/al/albertville/7661-highway-431-ste-300"
  ]
}' |
apify call datacach/dollar-tree-store-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dollar Tree Store Details Scraper",
        "description": "Extract complete Dollar Tree store details — address, phone number, GPS coordinates, and opening hours — for any US Dollar Tree location. Pair with the Dollar Tree Store Locator Scraper to turn a list of store URLs into structured, ready-to-use data.",
        "version": "0.0",
        "x-build-id": "Tg4arNPfCvl0azbzH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~dollar-tree-store-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-dollar-tree-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~dollar-tree-store-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datacach-dollar-tree-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~dollar-tree-store-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-dollar-tree-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 page URLs",
                        "type": "array",
                        "description": "Dollar Tree store page URLs to extract metadata from, e.g. <code>https://locations.dollartree.com/al/albertville/7661-highway-431-ste-300</code> — typically the output of the Dollar Tree 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. Higher values finish faster but increase the chance of anti-bot blocks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```