# Zumper Scraper — US Apartments & Houses for Rent (`khadinakbar/zumper-scraper`) Actor

Scrape Zumper rental listings by US city, Zumper search URL, or ZIP-adjacent area: rent price range, beds, baths, square feet, address, geo, building name, images, and listing URL. Auto-paginates past Zumper's 200-per-view cap via map-tiling. HTTP-only, fast, no login. PPE. MCP-ready.

- **URL**: https://apify.com/khadinakbar/zumper-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Zumper Scraper — US Apartments & Houses for Rent

Scrape rental listings from **Zumper** (zumper.com), one of the largest US apartment and house rental marketplaces. Give it a city or a Zumper search URL and get back a clean, structured dataset of every listing on the map — rent price range, bedrooms, bathrooms, square footage, address, geo-coordinates, building name, and the listing URL. HTTP-only and fast: no browser, no login, no cookies.

### What you get

One record per rental listing (building/property), with these fields:

| Field | Description |
|---|---|
| `buildingName` | Property / building name (e.g. "Camden Stoneleigh") |
| `address`, `city`, `state`, `zipcode` | Street address and location |
| `neighborhood` | Neighborhood name when Zumper provides it |
| `latitude`, `longitude` | Map coordinates |
| `minPrice`, `maxPrice` | Monthly rent range in USD across all floorplans |
| `minBedrooms`, `maxBedrooms` | Bedroom range (0 = studio) |
| `minBathrooms`, `maxBathrooms` | Bathroom range |
| `minSquareFeet`, `maxSquareFeet` | Square-footage range when available |
| `floorplanCount` | Number of distinct floorplans in the building |
| `isHouse` | `true` for houses/single-family, `false` for apartment buildings |
| `hasFees` | Whether Zumper flags application/other fees |
| `imageCount`, `imageIds` | Photo count and raw Zumper image IDs |
| `featureCodes` | Zumper amenity/feature codes |
| `listedAt`, `modifiedAt` | ISO 8601 timestamps |
| `propertyUrl` | Absolute Zumper listing URL (photos, floorplans, contact) |
| `listingId`, `buildingId`, `citySlug` | Stable identifiers |

### When to use it

- **Renters & relocation** — pull every current listing in a city into a spreadsheet and sort by price, beds, or location.
- **PropTech & real-estate analysts** — track rent ranges, inventory counts, and new listings across markets.
- **Lead generation** — build lists of rental buildings and property managers by city.
- **AI agents (MCP)** — a single, structured tool call: city in, JSON rentals out.

Not for: individual property deep-dives with full amenity text (use the `propertyUrl`), or non-US markets (Zumper is US-focused).

### Pricing

Pay-per-event:

- **Actor start** — $0.00005 per run.
- **Listing scraped** — $0.004 per rental listing returned.

A 200-listing run costs about **$0.80**. Billing is hard-capped at your **Max listings** value, and the run logs the maximum possible cost before it charges anything.

### Input

| Input | Description |
|---|---|
| `location` | US city as `"Austin, TX"` (or a Zumper slug like `austin-tx`). |
| `startUrls` | One or more Zumper search URLs (e.g. `https://www.zumper.com/apartments-for-rent/chicago-il`). Merged with `location`. |
| `maxResults` | Cost cap / max listings (default 200, up to 20000). |
| `minPrice`, `maxPrice` | Monthly-rent band filter (USD). |
| `minBedrooms`, `maxBedrooms` | Bedroom-count filter. |
| `proxyConfiguration` | Defaults to Apify datacenter US (cheapest; Zumper's API allows it). |

#### Example input

```json
{
  "location": "Austin, TX",
  "maxResults": 500,
  "minPrice": 1200,
  "maxPrice": 3000,
  "minBedrooms": 1
}
````

#### Multiple cities

```json
{
  "startUrls": [
    "https://www.zumper.com/apartments-for-rent/chicago-il",
    "https://www.zumper.com/apartments-for-rent/miami-fl"
  ],
  "maxResults": 1000
}
```

### How it works

1. Your location/URL is resolved to a Zumper **city slug** (`austin-tx`).
2. The actor fetches the city's GeoJSON boundary and reduces it to a bounding box.
3. It queries Zumper's internal `maplist/pins` API for that box. Zumper caps each response at **200 listings**, and returns a `matching` total for the box.
4. When a box holds more than 200 listings, the actor **quadtree-splits** it into four sub-boxes and recurses — so it paginates far past the 200-per-view cap and covers the whole city.
5. Listings are deduped by ID, filtered client-side (price/beds), and streamed to the dataset until `maxResults` is reached.

### Usage from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~zumper-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"location":"Austin, TX","maxResults":300}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/zumper-scraper").call(
    run_input={"location": "Austin, TX", "maxResults": 300}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["buildingName"], item["minPrice"], item["maxPrice"])
```

### MCP / AI agents

This actor is MCP-ready and exposed as `apify--zumper-scraper` in the Apify MCP server. It takes a narrow input (city or URL) and returns a compact, flat JSON record per listing — ideal for tool use by Claude, GPT, and other agents.

### Related actors

Part of a real-estate scraping cluster:

- [zillow-search-scraper](https://apify.com/khadinakbar/zillow-search-scraper) — Zillow listings.
- [rightmove-all-in-one-scraper](https://apify.com/khadinakbar/rightmove-all-in-one-scraper) — UK property.
- [idealista-scraper](https://apify.com/khadinakbar/idealista-scraper) — Spain/Italy/Portugal.
- [skip-trace-property-owner](https://apify.com/khadinakbar/skip-trace-property-owner) — US owner data.

### FAQ

**Does it need a login or cookies?** No. It uses Zumper's public internal API over plain HTTP.

**Why is a big city capped at my Max listings?** To control cost. Raise `maxResults` to go deeper; map-tiling will paginate automatically.

**Are the numbers exact?** Rent, beds, baths, and sqft are reported as the ranges Zumper publishes across a building's floorplans. Open the `propertyUrl` for per-unit detail.

### Legal

This actor collects only publicly available data from Zumper's website for lawful purposes such as market research and personal use. You are responsible for how you use the data, including compliance with Zumper's Terms of Service and applicable laws (e.g. GDPR/CCPA). It does not collect personal data or bypass any login.

# Actor input Schema

## `location` (type: `string`):

A US city to pull rental listings for, as "City, ST" or "City, State" (e.g. 'Austin, TX'). A Zumper city slug like 'austin-tx' also works. Leave empty if you provide Start URLs instead. This is NOT a street address or ZIP code — it targets a whole city.

## `startUrls` (type: `array`):

One or more Zumper search-page URLs to scrape (e.g. 'https://www.zumper.com/apartments-for-rent/austin-tx' or '/houses-for-rent/miami-fl'). Each resolves to a city and is merged with the Location field. Use this to batch several cities in one run. NOT individual property URLs.

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

Maximum number of listings to return across all locations, used to cap cost. Defaults to 200; range 1–20000. Big cities can exceed this, so raise it to go deeper (map-tiling paginates automatically). Billing is capped at this number.

## `minPrice` (type: `integer`):

Keep only listings whose rent range reaches at least this monthly amount in USD (e.g. 1500). Applied to each listing's price range after fetch. Leave empty for no minimum. NOT an exact-match filter — a listing passes if any of its floorplans could match.

## `maxPrice` (type: `integer`):

Keep only listings whose rent range starts at or below this monthly amount in USD (e.g. 3000). Applied to each listing's price range after fetch. Leave empty for no maximum. Combine with Min rent for a band.

## `minBedrooms` (type: `integer`):

Keep only listings offering at least this many bedrooms (e.g. 2). Studios count as 0. Leave empty for any size. Matches on the listing's maximum available bedroom count.

## `maxBedrooms` (type: `integer`):

Keep only listings offering at most this many bedrooms (e.g. 3). Leave empty for any size. Combine with Min bedrooms to target a specific unit size.

## `proxyConfiguration` (type: `object`):

Proxy settings. Zumper's API responds from datacenter IPs, so the default Apify datacenter US proxy is fine and cheapest. Override only if you hit intermittent blocks. Residential is rarely needed.

## Actor input object example

```json
{
  "location": "Austin, TX",
  "startUrls": [
    "https://www.zumper.com/apartments-for-rent/chicago-il"
  ],
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Scraped Zumper rental listings. Download as JSON, CSV, Excel, HTML, or RSS.

## `summary` (type: `string`):

End-of-run summary: cities scraped, listingsPushed, billedListings, estCostUsd.

# 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 = {
    "location": "Austin, TX",
    "startUrls": [],
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/zumper-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 = {
    "location": "Austin, TX",
    "startUrls": [],
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/zumper-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 '{
  "location": "Austin, TX",
  "startUrls": [],
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/zumper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zumper Scraper — US Apartments & Houses for Rent",
        "description": "Scrape Zumper rental listings by US city, Zumper search URL, or ZIP-adjacent area: rent price range, beds, baths, square feet, address, geo, building name, images, and listing URL. Auto-paginates past Zumper's 200-per-view cap via map-tiling. HTTP-only, fast, no login. PPE. MCP-ready.",
        "version": "1.0",
        "x-build-id": "FaJWHCWuqOHUchqoK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~zumper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-zumper-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/khadinakbar~zumper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-zumper-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/khadinakbar~zumper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-zumper-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "location": {
                        "title": "Location (US city)",
                        "type": "string",
                        "description": "A US city to pull rental listings for, as \"City, ST\" or \"City, State\" (e.g. 'Austin, TX'). A Zumper city slug like 'austin-tx' also works. Leave empty if you provide Start URLs instead. This is NOT a street address or ZIP code — it targets a whole city."
                    },
                    "startUrls": {
                        "title": "Zumper search URLs",
                        "type": "array",
                        "description": "One or more Zumper search-page URLs to scrape (e.g. 'https://www.zumper.com/apartments-for-rent/austin-tx' or '/houses-for-rent/miami-fl'). Each resolves to a city and is merged with the Location field. Use this to batch several cities in one run. NOT individual property URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all locations, used to cap cost. Defaults to 200; range 1–20000. Big cities can exceed this, so raise it to go deeper (map-tiling paginates automatically). Billing is capped at this number.",
                        "default": 200
                    },
                    "minPrice": {
                        "title": "Min rent (USD/mo)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings whose rent range reaches at least this monthly amount in USD (e.g. 1500). Applied to each listing's price range after fetch. Leave empty for no minimum. NOT an exact-match filter — a listing passes if any of its floorplans could match."
                    },
                    "maxPrice": {
                        "title": "Max rent (USD/mo)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings whose rent range starts at or below this monthly amount in USD (e.g. 3000). Applied to each listing's price range after fetch. Leave empty for no maximum. Combine with Min rent for a band."
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Keep only listings offering at least this many bedrooms (e.g. 2). Studios count as 0. Leave empty for any size. Matches on the listing's maximum available bedroom count."
                    },
                    "maxBedrooms": {
                        "title": "Max bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Keep only listings offering at most this many bedrooms (e.g. 3). Leave empty for any size. Combine with Min bedrooms to target a specific unit size."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Zumper's API responds from datacenter IPs, so the default Apify datacenter US proxy is fine and cheapest. Override only if you hit intermittent blocks. Residential is rarely needed.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
