# Zillow Photo Downloader (`solid-scraper/zillow-photo-downloader`) Actor

🏡 Zillow Photo Downloader quickly saves high-quality property photos for listings, marketing, and real estate projects. Fast, easy, and efficient—ideal for agents and agencies. ✅📸 Download smarter and showcase more.

- **URL**: https://apify.com/solid-scraper/zillow-photo-downloader.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Zillow Photo Downloader 📸

**Zillow Photo Downloader** is a focused data extraction tool that helps you scrape Zillow property URLs to extract all high-resolution images. Whether you’re looking for a **Zillow photo downloader** for bulk work, a **Zillow image downloader tool** for faster asset collection, or a **Zillow listing photo scraper** to support reporting and marketing workflows, this actor automates the tedious parts—so you can go from property links to usable photo sets at scale, saving you hours of manual work.

### Why choose Zillow Photo Downloader?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one Zillow photo extraction** | Extracts photos directly from the provided Zillow property URLs in one run |
| ✅ **Reliable scraping with built-in resilience** | Includes fallback-friendly processing and keeps batch runs moving property-by-property |
| ✅ **Structured JSON output** | Returns consistent fields like `jpegImages`, `webpImages`, `totalPhotos`, and `photos` for easy downstream use |
| ✅ **Designed for batch processing** | Works across multiple `propertyUrls`, making it practical for bulk download Zillow photos |
| ✅ **Automation-friendly dataset export** | Pushes results to an Apify dataset so you can export to JSON/CSV for other tools |
| ✅ **Proxy support for stable collection** | Uses built-in proxy support to improve reliability for repeated runs |

### Key features

- 📊 **High-resolution photo harvesting:** Extracts `jpegImages` and `webpImages` from each Zillow property page  
- 🏠 **Property URL input support:** Accepts a list of `propertyUrls` so you can run bulk jobs without manual reformatting  
- 📸 **Complete photo inventory:** Produces `totalPhotos` plus a full `photos` array with per-photo details  
- 🔍 **Quick first-photo access:** Includes `hiResImage` and `firstPhotoResolutions` for fast preview workflows  
- 🛡️ **Resilient batch behavior:** Each URL produces a result object with `success` and an `error` message when something goes wrong  
- 🌐 **Multi-format image URLs:** Collects both `jpegImages` and `webpImages` to fit different pipelines  
- 💾 **Dataset output for easy reuse:** Pushes collected results into the Apify dataset under `charged_event_name="result"`  

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "propertyUrls": [
    "https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/"
  ]
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `propertyUrls` | ✅ | A list of Zillow property page URLs the actor will scrape to extract images. Add one or many URLs for bulk Zillow photo downloader runs. |

### Output

After execution, the actor pushes an array of results to an Apify dataset in JSON format.

```json
[
  {
    "success": true,
    "zpid": "82443556",
    "propertyUrl": "https://www.zillow.com/homedetails/82443556_zpid/",
    "inputUrl": "https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/",
    "hiResImage": "https://.../image.jpg",
    "streetViewImage": null,
    "totalPhotos": 25,
    "jpegImagesCount": 10,
    "webpImagesCount": 15,
    "jpegImages": [
      "https://.../jpeg1.jpg",
      "https://.../jpeg2.jpg"
    ],
    "webpImages": [
      "https://.../webp1.webp",
      "https://.../webp2.webp"
    ],
    "firstPhotoResolutions": [
      {
        "url": "https://.../first-photo-resolution.jpg"
      }
    ],
    "photos": [
      {
        "photoIndex": 1,
        "jpeg": [
          {
            "url": "https://.../photo1-jpeg.jpg"
          }
        ],
        "webp": [
          {
            "url": "https://.../photo1-webp.webp"
          }
        ]
      }
    ]
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `success` | boolean | Whether the photo extraction succeeded for that input URL |
| `zpid` | string | Property identifier extracted from the page data |
| `propertyUrl` | string | Normalized Zillow property URL constructed from `zpid` |
| `inputUrl` | string | The exact Zillow URL you provided as input for this result |
| `hiResImage` | string | null | The first high-resolution JPEG URL if available (or `null` if not) |
| `streetViewImage` | null | Always `null` in the current output |
| `totalPhotos` | number | Total number of photo entries found for the property |
| `jpegImagesCount` | number | Number of collected JPEG image URLs in `jpegImages` |
| `webpImagesCount` | number | Number of collected WebP image URLs in `webpImages` |
| `jpegImages` | array | List of JPEG image URLs extracted from the page |
| `webpImages` | array | List of WebP image URLs extracted from the page |
| `firstPhotoResolutions` | array | Photo resolution objects for the first photo (as captured from the extracted photo data) |
| `photos` | array | Full per-photo structure including `photoIndex`, plus `jpeg` and `webp` arrays |
| `error` | string | Present when `success` is `false`; contains a failure reason (e.g., fetch failure, parsing issues) |
| `url` | string | Present in failure cases; the URL that failed |

> Exports: from the Apify dataset you can typically export the results to JSON and CSV depending on your workspace tools.

### How to use Zillow Photo Downloader (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**\
   Search for **Zillow Photo Downloader** in the Actors marketplace.

3. **Go to the INPUT panel**\
   Use the built-in form (or switch to raw input) to paste your JSON.

4. **Add your Zillow property URLs**\
   In `propertyUrls`, provide one or more Zillow homedetails URLs you want to download photos from (this powers your bulk download Zillow photos flow).

5. **Run the actor**\
   Click **Run**. The actor will process each URL and log progress as it scrapes and assembles image URLs.

6. **Watch logs during execution**\
   You’ll see which properties are being processed and whether each URL returns `success: true` or an `error`.

7. **Open the dataset output**\
   After completion, go to the **OUTPUT** section to open the dataset where results were pushed.

8. **Export results**\
   Export the dataset to JSON/CSV (depending on your Apify UI options) and feed it into your CRM, analysis pipeline, or creative workflow.

No coding required — get accurate Zillow listing images downloader results in minutes.

### Advanced features & SEO optimization

- 🚀 **Bulk download Zillow photos ready:** The actor accepts `propertyUrls` as an array, making it straightforward for bulk workflows like a Zillow photo gallery downloader
- 🔄 **Resilience per property:** Each URL produces its own result object, so partial runs still deliver usable output for successful pages (and clear `error` fields for failures)
- 📦 **Structured Zillow photo extraction output:** The consistent `jpegImages`, `webpImages`, and `photos` fields make Zillow property photo download pipelines easier to automate
- 🌐 **Image URL collection for multiple formats:** Collects both JPEG and WebP URLs so your downstream tools don’t need format conversions immediately
- 🕒 **Politeness delays for steadier runs:** Built-in timing helps support reliable batch execution when you process many Zillow image downloader tool targets

### Best use cases

- 📈 **Real estate marketers:** Generate photo sets from multiple listings to speed up campaigns without manual downloading of Zillow listing photo scraper assets
- 🏡 **Property analysts:** Quantify `totalPhotos`, `jpegImagesCount`, and `webpImagesCount` across neighborhoods for content-maturity comparisons
- 🎨 **Creative teams:** Pull image URLs for mood boards and creative variants when planning Zillow image downloader tool workflows at scale
- 🧠 **Market researchers:** Build datasets for Zillow photo extraction studies (e.g., comparing photo volume patterns by region)
- 🔁 **Lead generation ops:** Use listing images downloader output alongside your lead lists to enrich outreach materials
- 💻 **Developer pipelines:** Feed structured `photos` and `jpegImages`/`webpImages` fields into ETL jobs for reporting dashboards
- 📚 **Brand and PR research:** Collect visual assets across properties to support publishing, storytelling, and comparative analysis

### Technical specifications

- **Supported Input Formats**
  - ✅ `propertyUrls`: array of Zillow property URLs as strings

- **Proxy Support**
  - ✅ Built-in proxy support is enabled to improve reliability during scraping runs

- **Retry Mechanism**
  - ✅ Uses resilience patterns suitable for batch scraping (failures are captured per URL in the output)

- **Dataset Structure**
  - ✅ JSON array of result objects is pushed to the dataset

- **Rate Limits & Performance**
  - ✅ Includes politeness delays between requests to help keep runs stable across batches

- **Limitations**
  - ❌ If a page can’t be fetched or parsed, the result will be marked with `success: false` and include an `error`
  - ❌ Output depends on what image data is present on each provided property URL

### FAQ

#### ✅ What does Zillow Photo Downloader extract from each property URL?

Zillow Photo Downloader extracts photo information from each provided Zillow property page and returns structured JSON including `hiResImage`, `totalPhotos`, `jpegImages`, `webpImages`, and a full `photos` array with `photoIndex` and per-photo `jpeg`/`webp` structures.

#### ✅ What input does the actor require?

You must provide `propertyUrls`, which is a required array of Zillow property page URLs. The actor processes each URL in the list and returns a result object for it.

#### ❌ Do I need an account or login to run it?

This README is based strictly on the actor’s provided behavior and inputs. Practically, the run is driven by the `propertyUrls` input you supply in Apify Console; check the actor run logs for any page fetch issues captured via `success` and `error`.

#### 💻 Can I use Zillow Photo Downloader in an automated pipeline?

Yes. The actor pushes results to an Apify dataset in JSON format (and you can export from there). This makes it easy to integrate into a job that later consumes `jpegImages` and `webpImages` for automation.

#### 📦 Does the output always include high-resolution images?

Not always. When extraction succeeds, the output includes `hiResImage` (or `null` if not available) and photo counts like `totalPhotos`, `jpegImagesCount`, and `webpImagesCount`. If extraction fails, you’ll see `success: false` along with an `error`.

#### ⚖️ Is the data collected from publicly available sources?

✅ The actor is intended to scrape photo data from publicly available sources. You are responsible for ensuring your use complies with relevant laws and platform policies.

#### 🔍 How do I download the images themselves?

The actor provides image URLs in fields like `jpegImages` and `webpImages`. You can then download those URLs using your preferred tools after exporting dataset results.

#### 🗑️ Can I request data removal?

For data removal requests, contact <dataforleads@gmail.com>.

### Support & feature requests

Have questions about Zillow Photo Downloader or want improvements for your Zillow image downloader tool workflow? We’d love to hear from you.

- 💡 **Feature Requests:** Want enhancements like additional export formats or different photo selection strategies for Zillow thumbnail downloader-style workflows? Share your ideas with us.
- 📧 **Contact:** Send a message to <dataforleads@gmail.com>.

Your feedback helps shape future updates to this Zillow photo downloader script.

### Closing CTA / Final thoughts

*Zillow Photo Downloader makes bulk property photo extraction practical with clean, structured output for fast analysis and workflows.* If you’re building a **Zillow listing images downloader** pipeline, this actor is built to help you get results at scale.

### Disclaimer

**This tool accesses publicly accessible sources.** It does not access private profiles or password-protected data. It is your responsibility to comply with applicable laws (for example, GDPR and CCPA), spam regulations, and platform terms of service when using the results.

For data removal requests, please contact <dataforleads@gmail.com>. Use Zillow Photo Downloader responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `propertyUrls` (type: `array`):

List of Zillow property URLs to scrape.

## Actor input object example

```json
{
  "propertyUrls": [
    "https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/"
  ]
}
```

# 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 = {
    "propertyUrls": [
        "https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/zillow-photo-downloader").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 = { "propertyUrls": ["https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/"] }

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/zillow-photo-downloader").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 '{
  "propertyUrls": [
    "https://www.zillow.com/homedetails/3161-Ala-Ilima-St-APT-509-Honolulu-HI-96818/82443556_zpid/"
  ]
}' |
apify call solid-scraper/zillow-photo-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Photo Downloader",
        "description": "🏡 Zillow Photo Downloader quickly saves high-quality property photos for listings, marketing, and real estate projects. Fast, easy, and efficient—ideal for agents and agencies. ✅📸 Download smarter and showcase more.",
        "version": "0.1",
        "x-build-id": "idtwbwpILNOfadZq6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~zillow-photo-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-zillow-photo-downloader",
                "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/solid-scraper~zillow-photo-downloader/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-zillow-photo-downloader",
                "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/solid-scraper~zillow-photo-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-zillow-photo-downloader",
                "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": [
                    "propertyUrls"
                ],
                "properties": {
                    "propertyUrls": {
                        "title": "Zillow Property URLs",
                        "type": "array",
                        "description": "List of Zillow property URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```