# Redfin Scraper — Property Data, Redfin Estimate & Agent (`juramoshkov/redfin-property-agent-scraper`) Actor

Redfin scraper for US real estate data — listings with the Redfin Estimate, price & tax history, photos, schools, HOA, geo, plus listing agent and brokerage. Search by ZIP, city, URL, or listing URL. No API key, no run-start fee.

- **URL**: https://apify.com/juramoshkov/redfin-property-agent-scraper.md
- **Developed by:** [Jura Moshkov](https://apify.com/juramoshkov) (community)
- **Categories:** Real estate, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $45.00 / 1,000 enriched listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

<!--
MAINTAINER NOTE (not shown on the Apify Store page — HTML comments aren't rendered).
Shared RapidAPI-usage → Telegram reporter lives in @scrapers/core (packages/core/src/telegram-logger.ts).
Reuse it in this actor's src/main.ts exactly like realtor-property-agent:

  import { RapidApiUsageLogger } from "@scrapers/core";
  const usageStore = await Actor.openKeyValueStore("rapidapi-usage"); // NAMED store persists across runs
  const usage = new RapidApiUsageLogger({
    scraperName: "redfin-property-agent",
    store: {
      load: async (key) => Number((await usageStore.getValue(key)) ?? 0),
      save: async (key, total) => { await usageStore.setValue(key, total); },
    },
  });
  await usage.init();
  // pass onRapidApiRequest: () => usage.record() into the client, then at run end:
  await usage.flush();

Env: set TELEGRAM_BOT_TOKEN in the actor's Apify env vars (.env is NOT deployed). Group/topic ids are
hardcoded in telegram-logger.ts. Every 10 RapidAPI requests it posts: "📊 redfin-property-agent — N RapidAPI requests".
-->

## Redfin Scraper — Property Data, Redfin Estimate, Agent & Brokerage

**Redfin scraper for real estate property data.** Extract Redfin listings with **full property details, the Redfin Estimate, price & tax history, photos, schools — plus the listing agent's name and brokerage** in one flat row per property. Search by ZIP code, city, property URL, or a Redfin search URL. No browser automation, **no run-start fee**, and you pay only for successfully enriched results.

This real estate scraper turns Redfin into a clean, structured dataset: price, beds, baths, Redfin Estimate, price history, tax history, photos, and school ratings — with the listing agent and brokerage attached — exported to CSV, JSON, or Excel.

Looking for a **Redfin property scraper**, **Redfin Estimate data by ZIP code**, or **Redfin listings with agent & brokerage**? This actor does it in one run.

### ✨ Why this Redfin scraper

- 📈 **Redfin Estimate included** — pull Redfin's own valuation (plus high/low range) alongside the list price.
- 🏠 **40+ property fields** — price, beds/baths, sqft, lot, year built, HOA, days on market, price history, tax history, photos, schools, geo.
- 🧑‍💼 **Listing agent & brokerage** — the real listing agent's name and their brokerage on every listing (see note below).
- 🔎 **4 input modes** — ZIP search, city search, property-URL enrichment, or paste a Redfin search URL.
- 💸 **Pay only for results** — no run-start fee; charged per successfully enriched property.
- 📤 **Analysis-ready export** — flat rows to CSV / JSON / Excel, or straight into your workflow via Apify integrations.

> **Note on agent contact:** Redfin does not publish listing agents' phone numbers or email addresses on its listing pages — contact is routed through Redfin. This actor returns the **agent's name and brokerage** (real, per listing), but **not phone or email**. If you need agent email/phone, use the Realtor.com or Realtor.ca scrapers instead.

### Input modes

| Mode | Use it to | Requires |
|---|---|---|
| `zipSearch` | Discover all listings + agents in a ZIP code (main mode) | `zipCodes` |
| `citySearch` | Discover listings + agents in a city | `cities` |
| `propertyUrls` | Enrich a known list of Redfin property URLs | `startUrls` |
| `url` | Scrape any Redfin search/listing URL you paste | `startUrls` |

### Use cases

- **Real estate market research** — price, Redfin Estimate, price/tax history, and days-on-market analysis at scale.
- **Valuation & comps** — pull the Redfin Estimate (with high/low range) and recent sale history across a ZIP or city.
- **Investor & analytics pipelines** — feed structured Redfin listing data into dashboards, models, or spreadsheets.
- **Brokerage attribution** — see which brokerage and agent lists each property, by market.

### Input

**Search by ZIP code** (main mode):

```json
{
  "mode": "zipSearch",
  "zipCodes": ["98103"],
  "listingStatus": "forSale",
  "minPrice": 400000,
  "maxPrice": 1200000,
  "beds": 3,
  "maxResults": 100
}
````

**Enrich known Redfin property URLs:**

```json
{
  "mode": "propertyUrls",
  "startUrls": ["https://www.redfin.com/WA/Seattle/123-Main-St-98103/home/12345678"],
  "maxResults": 1
}
```

**Scrape a Redfin search URL:**

```json
{
  "mode": "url",
  "startUrls": ["https://www.redfin.com/zipcode/98103"],
  "listingStatus": "forSale",
  "maxResults": 100
}
```

### Output

One flat row per property. **Property fields:**

| Field | Type | Description |
|---|---|---|
| `propertyId` | string | Redfin property / listing ID. |
| `url` | string | Listing URL on Redfin. |
| `status` | string | Listing status (e.g. `for_sale`). |
| `price` | number | Listing price. |
| `currency` | string | Currency, usually USD. |
| `redfinEstimate` | number | Redfin Estimate valuation when available. |
| `beds` | number | Bedrooms. |
| `baths` | number | Bathrooms. |
| `sqft` | number | Interior square footage. |
| `lotSqft` | number | Lot size in square feet. |
| `yearBuilt` | number | Year built. |
| `propertyType` | string | Property type. |
| `streetAddress` / `city` / `state` / `zip` | string | Address parts. |
| `latitude` / `longitude` | number | Coordinates. |
| `hoaFee` | number | HOA fee when available. |
| `propertyTax` | number | Property tax when available. |
| `daysOnMarket` | number | Days on market. |
| `priceHistory` | array | Price history entries `{date, price, event}`. |
| `photoUrls` | array | Listing photo URLs. |
| `schools` | array | Nearby schools when available. |
| `listedDate` | string | Listing date (ISO). |

**Agent / brokerage fields:**

| Field | Type | Description |
|---|---|---|
| `agentName` | string | Listing agent name (real, per listing). |
| `brokerName` | string | Brokerage name. |
| `agentPhone` | string | Not provided by Redfin — always `null`. |
| `agentEmail` | string | Not provided by Redfin — always `null`. |
| `agentEmailMasked` | boolean | Always `false` (no email to mask). |
| `agentProfileUrl` | string | Agent profile URL when available. |

**Meta:** `mode`, `searchZip`, `sourceUrl`, `scrapedAt` (ISO), `error` (null on success).

### Pricing

**No run-start fee. You are charged only for successfully enriched properties.**

| Apify plan | Price per enriched property |
|---|---|
| Free | $0.07 |
| Bronze | $0.06 |
| Silver | $0.05 |
| Gold | $0.045 |
| Platinum | $0.04 |
| Diamond | $0.04 |

Free runs are capped at 15 enriched properties. Agent name, brokerage, Redfin Estimate, and all property data are returned on every plan. Upgrade your Apify plan for uncapped runs.

### FAQ

#### Does it include the agent's phone or email?

No. Redfin does not publish listing agents' phone numbers or email addresses — contact is routed through Redfin. This actor returns the listing **agent's name and brokerage** (real, per listing), but `agentPhone` and `agentEmail` are always `null`. For agent email and phone, use the Realtor.com or Realtor.ca scrapers.

#### How do I get Redfin property data by ZIP code?

Use `zipSearch` mode with one or more `zipCodes`. Each search returns listings with full property details, the Redfin Estimate, price/tax history, photos, schools, and the listing agent + brokerage.

#### What is the Redfin Estimate?

It is Redfin's own automated valuation for a home. This actor returns it in the `redfinEstimate` field alongside the list price when available.

#### Do I need an API key?

No. Just set your input and run — the actor handles everything.

#### How is this different from a Zillow or Realtor.com scraper?

It targets **Redfin** and combines listing data (including the Redfin Estimate) with the listing agent's contact details in the same row — built for lead generation, not just property data.

#### Is scraping Redfin legal?

The actor returns publicly available listing data. You are responsible for using exported data in compliance with applicable laws, platform terms, and outreach/marketing rules (e.g. consent for cold outreach).

### Coverage

United States listings only.

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `zipCodes` (type: `array`):

US ZIP codes to search in zipSearch mode.

## `cities` (type: `array`):

US cities to search in citySearch mode. Use city plus state, e.g. Seattle, WA.

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

Redfin search URLs for url mode, or property URLs for propertyUrls mode.

## `listingStatus` (type: `string`):

Which listings to return: for sale, for rent, or sold.

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

Max enriched properties per run. Each property costs ~1 upstream API request.

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

Only return listings priced at or above this amount (USD).

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

Only return listings priced at or below this amount (USD).

## `beds` (type: `integer`):

Only return listings with at least this many bedrooms.

## `baths` (type: `integer`):

Only return listings with at least this many bathrooms.

## `requestDelayMs` (type: `integer`):

Delay in milliseconds between requests. Increase on RapidAPI Basic plans.

## Actor input object example

```json
{
  "mode": "zipSearch",
  "zipCodes": [
    "98103"
  ],
  "cities": [
    "Seattle, WA"
  ],
  "listingStatus": "forSale",
  "maxResults": 5,
  "requestDelayMs": 1200
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `resultsCsv` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "zipCodes": [
        "98103"
    ],
    "cities": [
        "Seattle, WA"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("juramoshkov/redfin-property-agent-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 = {
    "zipCodes": ["98103"],
    "cities": ["Seattle, WA"],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("juramoshkov/redfin-property-agent-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 '{
  "zipCodes": [
    "98103"
  ],
  "cities": [
    "Seattle, WA"
  ],
  "maxResults": 5
}' |
apify call juramoshkov/redfin-property-agent-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper — Property Data, Redfin Estimate & Agent",
        "description": "Redfin scraper for US real estate data — listings with the Redfin Estimate, price & tax history, photos, schools, HOA, geo, plus listing agent and brokerage. Search by ZIP, city, URL, or listing URL. No API key, no run-start fee.",
        "version": "0.1",
        "x-build-id": "icRhEMFzb2yjwGDCD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/juramoshkov~redfin-property-agent-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-juramoshkov-redfin-property-agent-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/juramoshkov~redfin-property-agent-scraper/runs": {
            "post": {
                "operationId": "runs-sync-juramoshkov-redfin-property-agent-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/juramoshkov~redfin-property-agent-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-juramoshkov-redfin-property-agent-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "zipSearch",
                            "citySearch",
                            "propertyUrls",
                            "url"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "zipSearch"
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "US ZIP codes to search in zipSearch mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "US cities to search in citySearch mode. Use city plus state, e.g. Seattle, WA.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Redfin URLs",
                        "type": "array",
                        "description": "Redfin search URLs for url mode, or property URLs for propertyUrls mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingStatus": {
                        "title": "Listing status",
                        "enum": [
                            "forSale",
                            "forRent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which listings to return: for sale, for rent, or sold.",
                        "default": "forSale"
                    },
                    "maxResults": {
                        "title": "Max properties",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max enriched properties per run. Each property costs ~1 upstream API request.",
                        "default": 20
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount (USD)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount (USD)."
                    },
                    "beds": {
                        "title": "Min beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at least this many bedrooms."
                    },
                    "baths": {
                        "title": "Min baths",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with at least this many bathrooms."
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay in milliseconds between requests. Increase on RapidAPI Basic plans.",
                        "default": 1200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```