# Furnished Finder Scraper (`crawlerbros/furnished-finder-scraper`) Actor

Extract furnished rental listings from FurnishedFinder.com by city and state. Scrape price, bedrooms, bathrooms, amenities, photos, coordinates, ratings, and optional landlord contact info and reviews.

- **URL**: https://apify.com/crawlerbros/furnished-finder-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Other, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Furnished Finder Scraper

Extract furnished rental listings from [FurnishedFinder.com](https://www.furnishedfinder.com) by city and state. Fast, reliable, and no proxy required for most runs.

Whether you're tracking the mid-term rental market, building a rental aggregator, or doing real estate research, this scraper returns clean structured data for every listing: price, location, bedrooms, amenities, photos, and more.

### What It Scrapes

For every listing, you get:

- **Identity** — listing ID, canonical URL, title, property type (Apartment, House, Room, etc.)
- **Location** — city, state, latitude, longitude
- **Pricing** — monthly rent parsed to an integer USD value plus the raw display text, and fees such as deposit, cleaning, and pet fees
- **Specs** — bedrooms, bathrooms, square footage, minimum stay days
- **Content** — space description, neighborhood description, house rules
- **Amenities** — wifi, kitchen, laundry, pool, pet-friendly, and more
- **Bed and bath breakdown** — per-room list of bed types and bathroom types
- **Photos** — full-size image URLs
- **Ratings** — average rating and review count (when listed)
- **Metadata** — UTC `scrapedAt` timestamp on every record

#### Optional extras

- **`moreDetails` flag** — also attach the landlord profile: display name, profile image, username, tenure on the platform, verification badges (email, phone, ID), and a list of nearby hospitals with distances. Actual landlord email and phone are **not** included because FurnishedFinder gates direct contact behind a logged-in on-site messaging form.
- **`includeReviews` flag** — best-effort inclusion of individual reviews for properties where they are publicly embedded on the listing page.

### Inputs

| Field | Required | Description | Example |
|---|---|---|---|
| `city` | yes (unless `startUrls`) | City name to search | `"Austin"` |
| `state` | yes (unless `startUrls`) | US state — full name or 2-letter code | `"Texas"` or `"TX"` |
| `maxItems` | no | Max listings to scrape (default `20`, up to `1000`) | `50` |
| `minPrice` | no | Minimum monthly rent in USD | `1000` |
| `maxPrice` | no | Maximum monthly rent in USD | `3000` |
| `moveInDate` | no | Target move-in date (`YYYY-MM-DD`) | `"2026-09-01"` |
| `propertyType` | no | Filter by type — multi-select from `room` (private room) and `entire_unit` (whole unit). The granular type (`Apartment`, `House`, `Condo`, …) appears in the output `propertyType` field of every record regardless. | `["room","entire_unit"]` |
| `moreDetails` | no | Attach landlord profile fields (default `false`) | `true` |
| `includeReviews` | no | Attach reviews array when available (default `false`) | `true` |
| `startUrls` | no | Override search by passing FurnishedFinder URLs directly — search pages or `/property/{id}_{unit}` URLs. When set, `city` and `state` are ignored. | `[{"url":"https://www.furnishedfinder.com/property/979582_1"}]` |

### Output Example

Each dataset record is a flat JSON object. Here is a real record from a live run:

```json
{
  "id": "979582_1",
  "url": "https://www.furnishedfinder.com/property/979582_1",
  "title": "Redriver Haven",
  "propertyType": "Apartment",
  "city": "Austin",
  "state": "Texas",
  "latitude": 30.3024655,
  "longitude": -97.7216704,
  "monthlyPrice": 2000,
  "monthlyPriceText": "$2,000/month",
  "bedrooms": 1,
  "bathrooms": 1,
  "minimumStayDays": 30,
  "spaceDescription": "Quiet, fully furnished apartment near Red River St...",
  "utilitiesIncluded": true,
  "amenities": ["washeranddryeronpremises"],
  "houseRules": [{"name": "petsNotAllowed", "description": "Not Allowed"}],
  "bedList": [{"title": "Bedroom 1", "type": "Queen Bed"}],
  "bathList": [{"title": "Bathroom 1", "type": "Private Bath"}],
  "fees": [
    {"type": "Deposit (Refundable)", "amount": 300},
    {"type": "Cleaning Fee", "amount": 100}
  ],
  "photos": [
    "https://www.furnishedfinder.com/_pdp_/979582/1/979582_1_62490947-full.png"
  ],
  "scrapedAt": "2026-04-11T12:46:26.648593+00:00"
}
````

Fields that cannot be extracted for a particular listing are simply omitted from that record — you will never see `null` values.

### FAQ

**Do I need a proxy?**
No. The scraper works with plain HTTP requests out of the box. You can still attach an Apify proxy if you hit rate limits on very large runs.

**Does it use cookies or run a headless browser?**
No. It is a pure HTTP scraper, which makes it fast and cheap to run.

**Can I scrape a single property by URL?**
Yes — pass it in `startUrls` as `[{"url": "https://www.furnishedfinder.com/property/<id>_<unit>"}]` and the scraper will fetch just that one listing.

**Which states are supported?**
All 50 US states plus the District of Columbia. Enter the full name (`"Texas"`) or the 2-letter code (`"TX"`).

**How many listings can I get per city?**
Up to the `maxItems` value (default `20`, max `1000`). The scraper handles FurnishedFinder's result-per-request caps internally, so you don't have to think about pagination.

**What happens if a listing is missing a field?**
Fields that cannot be extracted for a particular listing are omitted from that record's JSON — no nulls. Your downstream pipeline always sees clean, well-typed data.

**Are duplicate listings possible?**
No. Results are deduplicated by property and unit ID within a single run.

**Does the scraper return landlord email and phone?**
No. FurnishedFinder does not publicly expose landlord email and phone — contacting a landlord goes through their on-site messaging form, which requires a login. The `moreDetails` flag still gives you the landlord's display name, profile image, verification badges (email/phone/ID verified), tenure on the platform, and a list of nearby hospitals, which is the public-facing contact information FurnishedFinder surfaces.

**How fresh is the data?**
Every run fetches live data from FurnishedFinder at the moment the actor runs. There is no cache — each record includes a `scrapedAt` UTC timestamp so you always know when it was captured.

**Can I filter by multiple property types at once?**
Yes. `propertyType` accepts an array. The two filter classes FurnishedFinder exposes are `room` (private room in a shared place) and `entire_unit` (whole apartment, house, or condo). To include both, pass `["room", "entire_unit"]`. The granular type — `Apartment`, `House`, `Condo`, etc. — is returned in the output `propertyType` field of every record so you can filter further downstream.

**Can I combine a price range with a move-in date?**
Yes. All filters (`minPrice`, `maxPrice`, `moveInDate`, `propertyType`) stack and are applied together.

### Use Cases

- **Real estate analytics** — track mid-term rental prices and inventory by city
- **Relocation research** — find furnished rentals meeting your price and move-in criteria
- **Competitive intelligence** — monitor what's listed in a particular market
- **Data enrichment** — augment your own property database with live market listings
- **Lead generation** — build a list of properties by area for outreach and marketing
- **Travel nursing and corporate housing** — surface 30+ day stays in target hospital markets

### Getting Started

1. Enter a `city` and `state` — that's all you need for a basic run.
2. Optional: add filters like `minPrice`, `maxPrice`, `moveInDate`, or `propertyType` to narrow results.
3. Optional: toggle `moreDetails` or `includeReviews` for richer output.
4. Click **Start** and get clean JSON listings in your dataset.

# Actor input Schema

## `city` (type: `string`):

City name to search for rentals (e.g. 'Austin', 'New York'). Required unless `startUrls` is provided.

## `state` (type: `string`):

US state — full name (e.g. 'Texas') or two-letter code (e.g. 'TX'). Required unless `startUrls` is provided.

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

Override city/state with explicit FurnishedFinder URLs — search pages or /property/{id}\_{unit} URLs. When set, city and state are ignored.

## `maxItems` (type: `integer`):

Maximum number of listings to scrape

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

Minimum monthly rent in USD

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

Maximum monthly rent in USD

## `moveInDate` (type: `string`):

Target move-in date in YYYY-MM-DD format

## `propertyType` (type: `array`):

Filter by property type. FurnishedFinder only exposes two filter classes: 'room' (private room in a shared place) and 'entire\_unit' (whole apartment/house/condo). The granular type (House, Condo, Apartment) appears in the output `propertyType` field of every record.

## `moreDetails` (type: `boolean`):

Also fetch landlord name, email, phone, street address, and nearby hospitals via mobile API. Adds one extra request per listing.

## `includeReviews` (type: `boolean`):

Try to extract individual review text, ratings, and dates when FurnishedFinder embeds them in the property page. Note: only a small fraction of FurnishedFinder properties expose reviews in the page payload — most only expose `avgRating` and `totalReviewCount`. The rating/count fields are extracted regardless of this toggle when present.

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

Optional proxy. Not required — FurnishedFinder does not block plain requests.

## Actor input object example

```json
{
  "city": "Austin",
  "state": "Texas",
  "maxItems": 5,
  "moreDetails": false,
  "includeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (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 = {
    "city": "Austin",
    "state": "Texas",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/furnished-finder-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 = {
    "city": "Austin",
    "state": "Texas",
    "maxItems": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/furnished-finder-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 '{
  "city": "Austin",
  "state": "Texas",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/furnished-finder-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Furnished Finder Scraper",
        "description": "Extract furnished rental listings from FurnishedFinder.com by city and state. Scrape price, bedrooms, bathrooms, amenities, photos, coordinates, ratings, and optional landlord contact info and reviews.",
        "version": "1.0",
        "x-build-id": "agO7j8RpOl8BNHfrw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~furnished-finder-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-furnished-finder-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/crawlerbros~furnished-finder-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-furnished-finder-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/crawlerbros~furnished-finder-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-furnished-finder-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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to search for rentals (e.g. 'Austin', 'New York'). Required unless `startUrls` is provided."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "US state — full name (e.g. 'Texas') or two-letter code (e.g. 'TX'). Required unless `startUrls` is provided."
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Override city/state with explicit FurnishedFinder URLs — search pages or /property/{id}_{unit} URLs. When set, city and state are ignored.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape",
                        "default": 20
                    },
                    "minPrice": {
                        "title": "Min Price (USD/month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum monthly rent in USD"
                    },
                    "maxPrice": {
                        "title": "Max Price (USD/month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum monthly rent in USD"
                    },
                    "moveInDate": {
                        "title": "Move-in Date",
                        "type": "string",
                        "description": "Target move-in date in YYYY-MM-DD format"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by property type. FurnishedFinder only exposes two filter classes: 'room' (private room in a shared place) and 'entire_unit' (whole apartment/house/condo). The granular type (House, Condo, Apartment) appears in the output `propertyType` field of every record.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "room",
                                "entire_unit"
                            ]
                        }
                    },
                    "moreDetails": {
                        "title": "Fetch Landlord Details",
                        "type": "boolean",
                        "description": "Also fetch landlord name, email, phone, street address, and nearby hospitals via mobile API. Adds one extra request per listing.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Try to extract individual review text, ratings, and dates when FurnishedFinder embeds them in the property page. Note: only a small fraction of FurnishedFinder properties expose reviews in the page payload — most only expose `avgRating` and `totalReviewCount`. The rating/count fields are extracted regardless of this toggle when present.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy. Not required — FurnishedFinder does not block plain requests.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
