# Usa Pet Services Extractor (`b2b_lead_generation/usa-pet-services-extractor`) Actor

Deploy an ultra-fast retrieval engine to target and extract American pet care service contacts. Instantly access verified dog walkers, pet sitters, grooming salons, and boarding lodges across all 50 US states with phone and direct email all with zero scraping blocks or delays.

- **URL**: https://apify.com/b2b\_lead\_generation/usa-pet-services-extractor.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## USA Pet Services Leads Hub 🐾✨

<p align="center">
  <img src="https://imgur.com/pcdcfZj.png" alt="USA Pet Services Leads Hub" style="max-width:100%; border-radius:14px; width:680px;" />
</p>

#### ⚡ Instant USA B2B Pet Care Services & Contacts Extractor
Deploy a state-of-the-art retrieval solution to target and extract **American pet care service business contacts** across thousands of specialized sectors. Powered by an ultra-fast indexing engine, this extractor delivers instant access to verified pet business names, direct contact phones, email addresses, websites, and complete physical locations.

Whether you need to build local pet care directories or fuel enterprise-level B2B sales pipelines, you can define your target pet service categories, apply precise registry filters, and generate ready-to-use lists in seconds.

---

### 🎯 Key Capabilities

* **Target Any Pet Niche**: Search professional dog walkers, pet sitters, specialized pet grooming salons, pet boarding facilities, pet cemeteries, and more.
* **Granular Registry Sector Filters**: Narrow down searches by targeting specific commercial directories independently (e.g., `Dog_Walker`, `Dog_Sitter`, `Pet_grooming`, `Pet_boarding_facility`, `Pet_Cemetery`).
* **Multi-Category Parallel Search**: Input multiple target terms simultaneously. The extractor searches each term sequentially and builds a single, deduplicated export.
* **Flexible Matching Engine**: Toggle between broad substring matching (e.g., `groom` matches `Grooming Salon` and `Pet groomer`) or precise full-word boundary matching.
* **Custom Extraction Limits**: Pull a fast sample of 100 listings or run a comprehensive campaign extraction up to 100,000 records.
* **Zero-Hassle Export Formats**: Download clean, structured datasets in CSV, Excel, or JSON format directly from your Apify Console.

---

### 💼 High-Impact Use Cases

* **B2B Pet Industry Sales & Outreach**: Identify high-value pet grooming business owners, boarding facility operators, pet supply manufacturers, and veterinarians matching your ideal customer profile (ICP).
* **Cold Email & Marketing Campaigns**: Feed your marketing sequences with clean, verified email addresses mapped to specific US pet service niches.
* **Recruitment & Partnership Development**: Discover pet care practices in specific regions to pitch corporate headhunting, specialized CRM software, veterinary tools, or localized pet marketing services.
* **Market Mapping & Competitor Analysis**: Analyze the concentration and distribution of pet care service practices across US states and metropolitan areas.
* **Local Business Directories**: Build, enrich, or refresh local pet service directories and finder apps with up-to-date business contact data.

---

### ⚙️ Input Configuration

The extractor accepts highly customizable, optional search criteria. For the best results, defining at least one category keyword or target registry sector is recommended.

#### Extraction Parameters

| Field Name | Type | Description |
|:---|:---|:---|
| `categories` | `array` | Category keywords to search within listing descriptions (one per line). Supports partial terms (e.g., `groom` matches `Pet grooming salon`, `Dog groomer`). Case-insensitive. |
| `sourceCategories` | `array` | Specific pet care registry sectors to filter by (e.g., `Dog_Walker`, `Dog_Sitter`, `Pet_grooming`, `Pet_boarding_facility`, `Pet_Cemetery`). Limits extraction to listings matching these primary directory sectors. |
| `matchType` | `select` | Choose match style: `any_character` (flexible substring search) or `full_word` (exact word boundaries to reduce search noise). Default: `any_character`. |
| `limit` | `integer` | Maximum number of records to return. Min: `100`, Max: `100,000`, Default: `500`. |

---

#### Example Configurations

##### 🔹 Scenario A: Simple Sector Extraction
Extract listings from a single pet care sector.
```json
{
    "sourceCategories": ["Pet_grooming"],
    "matchType": "any_character",
    "limit": 500
}
````

##### 🔹 Scenario B: Multi-Sector Lead Generation

Compile contacts from multiple diverse pet care registries.

```json
{
    "sourceCategories": ["Dog_Walker", "Dog_Sitter", "Pet_boarding_facility"],
    "matchType": "any_character",
    "limit": 3000
}
```

##### 🔹 Scenario C: Hyper-Targeted Search

Combine specific text search queries with registry filters using precise full-word matching.

```json
{
    "categories": ["Pet grooming salon", "Mobile dog wash"],
    "sourceCategories": ["Pet_grooming"],
    "matchType": "full_word",
    "limit": 2000
}
```

***

### 📊 Extracted Output Format

Every record retrieved by the extractor represents a verified US pet care business listing. Results are delivered in real-time to your dataset.

#### Sample JSON Output

```json
{
    "name": "Bare Paws NYC Dog Walkers & Pet Sitters",
    "categories": "Dog walker;Pet sitter;Dog boarding;Cat boarding",
    "phone": "+16464361687",
    "email": "contact@barepawsnyc.com",
    "address": "157 East 86th St 5th floor, New York, NY 10028",
    "website": "http://fourbarepaws.com/",
    "source_category": "Dog_Sitter"
}
```

#### Output Field Descriptions

| Column Name | Type | Description |
|:---|:---|:---|
| `name` | `string` | Registered pet care business or professional practitioner name. |
| `categories` | `string` | Semicolon-separated categories describing the firm's services. |
| `phone` | `string` | Contact phone number in standardized international format. |
| `email` | `string` | Direct contact email address (where publicly available). |
| `address` | `string` | Complete physical mailing address including city, state, and ZIP. |
| `website` | `string` | Verified URL of the business website. |
| `source_category` | `string` | The parent registry sector from which the listing was retrieved. |

***

### 📂 Popular Directory Sectors

Target these primary directory sectors inside `sourceCategories` or use them as search keywords in the `categories` input list.

#### 🐕 Pet Sitting & Walking

- `Dog_Walker`: Professional dog walking services, daily dog runs, and pet taxi coordinators.
- `Dog_Sitter`: Daily pet sitting, house sitting, cat sitting, and specialized in-home pet care services.

#### ✂️ Pet Grooming & Styling

- `Pet_grooming`: Professional pet grooming salons, pet styling, dog washing, claw trimming, and mobile dog washers.

#### 🏨 Pet Boarding & Lodging

- `Pet_boarding_facility`: Pet boarding hotels, luxury dog lodges, dog daycare centers, and overnight pet lodging.

#### 🕯️ Pet Memorials & Cemeteries

- `Pet_Cemetery`: Pet crematoriums, pet cemeteries, pet funeral coordinators, and memorial services.

<p align="center">
  <img src="https://imgur.com/0maVi0S.png" alt="USA Pet Services Leads Hub Categories" style="max-width:100%; border-radius:14px; width:680px;" />
</p>

#### 🔗 Comprehensive Category Reference

For a complete listing of all indexed registry categories, refer to the online index:
👉 [All USA Pet Services Categories Directory](https://github.com/kawsarlog/automatic-text/blob/main/USA%20Pet%20Services%20Extractor.txt)

***

### 🗺️ Geographic Distribution

The extraction engine indexes pet service listings across all 50 US states. You can segment results geographically by downloading the dataset and sorting by state or zip code.

- **New York (NY)**: New York City, Brooklyn, Buffalo, Rochester, Yonkers, Albany, Queens, Flushing
- **California (CA)**: Los Angeles, San Diego, San Jose, San Francisco, Fresno, Sacramento, Oakland, Anaheim
- **Texas (TX)**: Houston, San Antonio, Dallas, Austin, Fort Worth, El Paso, Arlington, Plano, Lubbock
- **Florida (FL)**: Jacksonville, Miami, Tampa, Orlando, St. Petersburg, Tallahassee, Fort Lauderdale
- **Illinois (IL)**: Chicago, Aurora, Rockford, Joliet, Naperville, Springfield, Peoria, Champaign
- **Pennsylvania (PA)**: Philadelphia, Pittsburgh, Allentown, Erie, Reading, Scranton, Harrisburg, Lancaster

***

### 💡 Pro Extraction Tips

1. **Leverage Broad Terms**: Use broad root words in `categories` (e.g., `board`) to capture pet boarding facilities, dog boarding, cat boarding, and luxury boarding in one pass.
2. **Combine Sector Filters**: Enter multiple target sectors in `sourceCategories` to fetch overlapping pet service fields cleanly.
3. **Exact Word Matching**: If you receive unrelated results, switch `matchType` to `full_word` to enforce strict search boundaries.
4. **Export Clean Files**: Always run the extractor to your target limit, then download the resulting dataset and filter by state or email-presence inside Excel or Google Sheets.

***

### 🔄 Integrations & Pipelines

Pipe your retrieved pet industry contacts directly into your active B2B software stacks using Apify Integrations:

- **Spreadsheets**: Sync directly with Google Sheets for real-time list building.
- **Workflows**: Connect via Zapier or Make to trigger outbound emails automatically.
- **CRMs**: Stream listings straight into Salesforce, HubSpot, or Pipedrive.
- **Webhooks**: Fire webhooks the instant an extraction run completes.

<p align="center">
  <img src="https://imgur.com/d3DAzwk.png" alt="USA Pet Services Leads Hub Results Showcase" style="max-width:100%; border-radius:12px; width:680px;" />
</p>

***

### ❓ Frequently Asked Questions

> **Why do some records lack email addresses?**
> Email addresses are only extracted when publicly listed by the business. For listings without an email, the phone number, full address, and website URL are provided, which are ideal for alternative multichannel outreach.

> **Why did my run finish with fewer results than the limit?**
> The extractor only stops when it reaches your requested limit OR when it runs out of matching listings in the directory index. If a specific keyword has listings and your limit is set higher, you will receive exactly the matching listings. Try using broader keywords to expand coverage.

> **Can I search multiple categories at once?**
> Yes. Use the `categories` or `sourceCategories` fields and enter one keyword per line. The platform searches each in sequence and merges all results into a single dataset run.

> **Do I need to configure proxy settings?**
> No proxy configuration is required. The extractor runs against a fully indexed local dataset engine, delivering high performance and instant retrieval without IP blocks or scraping delays.

# Actor input Schema

## `categories` (type: `array`):

Filter by business categories (e.g. Pet sitter, Dog walker). The search is case-insensitive.

Link : https://github.com/kawsarlog/automatic-text/blob/main/USA%20Pet%20Services%20Extractor.txt

## `sourceCategories` (type: `array`):

Filter by source category values (e.g. Dog\_Sitter). The search is case-insensitive.

## `matchType` (type: `string`):

Match type to use for filtering. 'Any Character (Substring Match)' finds partial matches. 'Full Word (Exact Match)' checks for exact phrase elements.

## `limit` (type: `integer`):

Maximum number of filtered listings to return (min: 100, max: 100,000).

## Actor input object example

```json
{
  "categories": [
    "Pet sitter",
    "Dog walker"
  ],
  "sourceCategories": [
    "Dog_Sitter"
  ],
  "matchType": "any_character",
  "limit": 500
}
```

# 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 = {
    "categories": [
        "Pet sitter",
        "Dog walker"
    ],
    "sourceCategories": [
        "Dog_Sitter"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/usa-pet-services-extractor").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 = {
    "categories": [
        "Pet sitter",
        "Dog walker",
    ],
    "sourceCategories": ["Dog_Sitter"],
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/usa-pet-services-extractor").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 '{
  "categories": [
    "Pet sitter",
    "Dog walker"
  ],
  "sourceCategories": [
    "Dog_Sitter"
  ]
}' |
apify call b2b_lead_generation/usa-pet-services-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b2b_lead_generation/usa-pet-services-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Usa Pet Services Extractor",
        "description": "Deploy an ultra-fast retrieval engine to target and extract American pet care service contacts. Instantly access verified dog walkers, pet sitters, grooming salons, and boarding lodges across all 50 US states with phone and direct email all with zero scraping blocks or delays.",
        "version": "0.0",
        "x-build-id": "vV20LH0dsxyUUps3u"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~usa-pet-services-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-usa-pet-services-extractor",
                "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/b2b_lead_generation~usa-pet-services-extractor/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-usa-pet-services-extractor",
                "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/b2b_lead_generation~usa-pet-services-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-usa-pet-services-extractor",
                "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": {
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by business categories (e.g. Pet sitter, Dog walker). The search is case-insensitive.\n\n Link : https://github.com/kawsarlog/automatic-text/blob/main/USA%20Pet%20Services%20Extractor.txt",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceCategories": {
                        "title": "Source categories",
                        "type": "array",
                        "description": "Filter by source category values (e.g. Dog_Sitter). The search is case-insensitive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "matchType": {
                        "title": "Match type",
                        "enum": [
                            "any_character",
                            "full_word"
                        ],
                        "type": "string",
                        "description": "Match type to use for filtering. 'Any Character (Substring Match)' finds partial matches. 'Full Word (Exact Match)' checks for exact phrase elements.",
                        "default": "any_character"
                    },
                    "limit": {
                        "title": "Limit results",
                        "minimum": 100,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of filtered listings to return (min: 100, max: 100,000).",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
