# Apartments Scraper (Cheap) (`data_api/apartments-scraper-cheap`) Actor

Pulls apartment listings from Apartments.com. Point it at a city or neighborhood search URL and it returns prices, floor plans, amenities, and contact details as a structured dataset.

- **URL**: https://apify.com/data\_api/apartments-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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/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

## Apartments.com Rental Scraper

![Apartments.com Rental Scraper](cover.jpg)

Pulling rental data off Apartments.com by hand is slow work: every city has hundreds of result pages, the rent only shows up on the card, and the floor plans and amenities sit one click deeper. This scraper does the clicking for you. Point it at a city page, a filtered search, or a single property, and it returns each rental as one clean row with the name, monthly rent, address, phone, amenities, and photos. Pagination is handled on its own, so a single URL can turn into a full city dataset.

### What you get

Every rental comes back as one row with a steady set of columns. When a value is missing it returns as `null` rather than disappearing, so the data stays rectangular for a spreadsheet or database load. The fields fall into a few groups:

- **Property and location** — `propertyName`, `fullAddress`, `streetName`, `cityName`, `stateCode`, `postalCode`, plus map `lat` / `lng`
- **Rent and units** — `rentMin`, `rentMax`, `bedroomPricing`, and `floorPlans` (beds, baths, square footage, rent range, availability)
- **Amenities and flags** — `amenityList` plus quick booleans `petsAllowed`, `parkingAvailable`, `poolAvailable`, `gymAvailable`
- **Contact and media** — `contactPhone`, `propertyWebsite`, `coverPhoto`, `photoLinks`
- **Reputation** — `starRating`, `reviewsTotal`, and the full `listingDescription`

### Quick start

1. Open the actor and go to the input form.
2. Paste one or more Apartments.com URLs into **Apartments.com URLs**.
3. Flip on **Open each rental page** if you want coordinates, floor plans, full amenities, and all photos.
4. Set a **Results limit** to cap the run, then press **Start** and export as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

The scraper accepts:

- City pages: `https://www.apartments.com/austin-tx/`
- Filtered searches: `https://www.apartments.com/seattle-wa/2-bedrooms/`
- Single property pages: `https://www.apartments.com/the-name-city-st/xyz789/`

### Use cases

- **Rent tracking** — watch how asking rents move month to month across a city or neighborhood and re-run on a schedule
- **Real estate analysis** — compare price-per-sqft, bedroom mix, and amenity profiles across several markets before site visits
- **Lead lists** — gather leasing phone numbers and property websites for a target city, then export to CSV for outreach
- **Market research** — break down average rent by bedroom count, pet policy, or ZIP code and join it to census data
- **Competitive watch** — follow a rival community's pricing and the floor plans it still has available over time

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `listingUrls` | array of strings | Yes | Apartments.com search or property URLs to scrape. City pages, filtered searches, and single property pages all work. |
| `fetchDetailPages` | boolean | No | Open each property page for coordinates, floor plan sqft, full amenities, all photos, rating, and description. Costs one extra credit per rental. Default `false`. |
| `withFloorPlans` | boolean | No | With detail pages on, attach per-unit floor plan rows. Default `false`. |
| `withAmenities` | boolean | No | With detail pages on, attach the full amenity list per rental. Default `false`. |
| `resultsLimit` | integer | No | Stop after this many rentals (up to 1000). Default `40`. |
| `timeoutSeconds` | integer | No | Seconds to wait on a single request before giving up. Default `75`. |

#### Example input

```json
{
    "listingUrls": [
        "https://www.apartments.com/austin-tx/",
        "https://www.apartments.com/seattle-wa/2-bedrooms/"
    ],
    "fetchDetailPages": true,
    "withFloorPlans": true,
    "withAmenities": true,
    "resultsLimit": 40,
    "timeoutSeconds": 75
}
````

### Output

Each rental becomes one row, and every field is always present — values the page does not expose come back as `null` so your dataset stays rectangular.

#### Example output

```json
{
    "listingUrl": "https://www.apartments.com/the-quarry-austin-tx/xyz789/",
    "listingId": "xyz789",
    "propertyName": "The Quarry",
    "fullAddress": "2400 E Riverside Dr, Austin, TX 78741",
    "streetName": "2400 E Riverside Dr",
    "cityName": "Austin",
    "stateCode": "TX",
    "postalCode": "78741",
    "lat": 30.23456,
    "lng": -97.72103,
    "contactPhone": "(512) 555-0142",
    "propertyWebsite": "https://www.thequarryaustin.com/",
    "listingDescription": "Modern one and two bedroom apartments minutes from downtown Austin...",
    "starRating": 4.2,
    "reviewsTotal": 58,
    "rentMin": 1395,
    "rentMax": 2480,
    "bedroomPricing": [
        { "beds": "Studio", "priceFrom": "$1,395+", "priceFromInt": 1395 },
        { "beds": "1 Bed", "priceFrom": "$1,650+", "priceFromInt": 1650 },
        { "beds": "2 Beds", "priceFrom": "$2,100+", "priceFromInt": 2100 }
    ],
    "floorPlans": [
        {
            "name": "Studio",
            "beds": "Studio",
            "baths": "1",
            "sqftMin": 480,
            "sqftMax": 520,
            "priceMin": 1395,
            "priceMax": 1480,
            "available": true
        },
        {
            "name": "2 Bedroom",
            "beds": "2",
            "baths": "2",
            "sqftMin": 980,
            "sqftMax": 1100,
            "priceMin": 2100,
            "priceMax": 2480,
            "available": true
        }
    ],
    "amenityList": [
        "Pool",
        "Fitness Center",
        "In Unit Washer & Dryer",
        "Covered Parking",
        "Pet Friendly"
    ],
    "coverPhoto": "https://images1.apartments.com/i2/abcd1234/primary-photo.jpg",
    "photoLinks": [
        "https://images1.apartments.com/i2/abcd1234/primary-photo.jpg",
        "https://images1.apartments.com/i2/efgh5678/building-photo.jpg"
    ],
    "petsAllowed": true,
    "parkingAvailable": true,
    "poolAvailable": true,
    "gymAvailable": true,
    "collectedAt": "2026-06-29T12:00:00.000000+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingUrl` | string | Direct link to the Apartments.com rental page |
| `listingId` | string | The identifier Apartments.com assigns to the rental |
| `propertyName` | string | Name of the apartment community or building |
| `fullAddress` | string | Complete address line shown on the rental |
| `streetName` | string | Street part of the property address |
| `cityName` | string | City the property sits in |
| `stateCode` | string | Two-letter US state abbreviation |
| `postalCode` | string | Postal code for the property |
| `lat` | number | Map latitude for the property |
| `lng` | number | Map longitude for the property |
| `contactPhone` | string | Leasing contact phone for the property |
| `propertyWebsite` | string | Outside website link for the property when one is published |
| `listingDescription` | string | Full write-up text taken from the rental page |
| `starRating` | number | Average renter score from 1 to 5 stars |
| `reviewsTotal` | integer | How many renter reviews the property has |
| `rentMin` | integer | Cheapest monthly rent across the available units |
| `rentMax` | integer | Priciest monthly rent across the available units |
| `bedroomPricing` | array | Starting rent for each bedroom type from the search card |
| `floorPlans` | array | Per-unit floor plan rows, populated when detail pages are opened |
| `coverPhoto` | string | Lead property photo URL grabbed from the search card |
| `amenityList` | array | Amenity labels found on the rental, such as pool, gym, or parking |
| `photoLinks` | array | Collection of property photo URLs |
| `petsAllowed` | boolean | True when the rental notes that pets are welcome |
| `parkingAvailable` | boolean | True when parking shows up in the amenities |
| `poolAvailable` | boolean | True when a pool shows up in the amenities |
| `gymAvailable` | boolean | True when a fitness center or gym shows up in the amenities |
| `collectedAt` | string | ISO 8601 timestamp for when the row was captured |
| `errorMessage` | string | Why a rental failed; `null` on success |

### Tips for best results

- **Try a few URLs first.** Run 10 rentals before committing to a whole city. URL-format and limit issues show up in the first rows.
- **Keep detail pages off for a quick pass.** Search-card data already gives you name, rent, address, phone, and amenity tags. Turn on **Open each rental page** only when you need coordinates, floor plans, or all photos, since it costs an extra credit per rental.
- **Use `resultsLimit` to control spend.** Big cities run to hundreds of result pages at roughly 40 rentals each, so set a cap while you tune your pipeline.
- **Expect some null rents.** When a property only shows a contact form, `rentMin` and `rentMax` come back `null`. That is a data limit, not an error.
- **Raise `timeoutSeconds`** if you see timeout errors on large or slow pages.

### How can I use Apartments.com rental data?

**How can I use the Apartments.com Rental Scraper to build a rent dataset for a city?**
Paste a city page such as `https://www.apartments.com/austin-tx/` and the scraper walks every result page, returning each rental's name, monthly rent range, address, and amenities as one row. Group by ZIP code or bedroom count to chart asking rents and supply, then re-run on a schedule to track how the market moves.

**How can I scrape Apartments.com floor plans and amenities for a property?**
Drop a single property URL into `listingUrls` and turn on **Open each rental page** with `withFloorPlans` and `withAmenities`. You get per-unit beds, baths, square footage, and rent ranges in `floorPlans`, the complete `amenityList`, plus coordinates and every photo — the full picture for one community in a single row.

**How can I pull leasing contact details from Apartments.com for outreach?**
Run a city or filtered search and the scraper returns `contactPhone` and `propertyWebsite` for each rental alongside the property name and address. Export to CSV, filter for the rentals that fit your criteria, and you have a ready outreach list without copying numbers off pages by hand.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `listingUrls` (type: `array`):

Paste one or more Apartments.com search or rental URLs. Works with city pages such as https://www.apartments.com/austin-tx/, filtered searches like https://www.apartments.com/seattle-wa/2-bedrooms/, and single property pages such as https://www.apartments.com/the-name-city-st/xyz789/.

## `fetchDetailPages` (type: `boolean`):

Open every property page to pull richer data: map coordinates, floor plan square footage, the complete amenity list, all photos, rating, and the full description. Costs one extra credit per rental. Leave off to keep search-card data only (name, address, phone, rent, amenity tags, thumbnail).

## `withFloorPlans` (type: `boolean`):

With detail pages turned on, attach per-unit floor plan rows covering beds, baths, square footage, rent range, and availability.

## `withAmenities` (type: `boolean`):

With detail pages turned on, attach the full amenity list for each rental.

## `resultsLimit` (type: `integer`):

Stop the run once this many rentals have been gathered.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up. Bump it up if you run into timeout errors.

## Actor input object example

```json
{
  "listingUrls": [
    "https://www.apartments.com/austin-tx/",
    "https://www.apartments.com/seattle-wa/2-bedrooms/"
  ],
  "fetchDetailPages": false,
  "withFloorPlans": false,
  "withAmenities": false,
  "resultsLimit": 40,
  "timeoutSeconds": 75
}
```

# 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 = {
    "listingUrls": [
        "https://www.apartments.com/austin-tx/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/apartments-scraper-cheap").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 = { "listingUrls": ["https://www.apartments.com/austin-tx/"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/apartments-scraper-cheap").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 '{
  "listingUrls": [
    "https://www.apartments.com/austin-tx/"
  ]
}' |
apify call data_api/apartments-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apartments Scraper (Cheap)",
        "description": "Pulls apartment listings from Apartments.com. Point it at a city or neighborhood search URL and it returns prices, floor plans, amenities, and contact details as a structured dataset.",
        "version": "0.0",
        "x-build-id": "WGKwJO3YzhgFvIrJG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~apartments-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-apartments-scraper-cheap",
                "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/data_api~apartments-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-apartments-scraper-cheap",
                "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/data_api~apartments-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-apartments-scraper-cheap",
                "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": [
                    "listingUrls"
                ],
                "properties": {
                    "listingUrls": {
                        "title": "Apartments.com URLs",
                        "type": "array",
                        "description": "Paste one or more Apartments.com search or rental URLs. Works with city pages such as https://www.apartments.com/austin-tx/, filtered searches like https://www.apartments.com/seattle-wa/2-bedrooms/, and single property pages such as https://www.apartments.com/the-name-city-st/xyz789/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetailPages": {
                        "title": "Open each rental page",
                        "type": "boolean",
                        "description": "Open every property page to pull richer data: map coordinates, floor plan square footage, the complete amenity list, all photos, rating, and the full description. Costs one extra credit per rental. Leave off to keep search-card data only (name, address, phone, rent, amenity tags, thumbnail).",
                        "default": false
                    },
                    "withFloorPlans": {
                        "title": "Add floor plans",
                        "type": "boolean",
                        "description": "With detail pages turned on, attach per-unit floor plan rows covering beds, baths, square footage, rent range, and availability.",
                        "default": false
                    },
                    "withAmenities": {
                        "title": "Add amenity list",
                        "type": "boolean",
                        "description": "With detail pages turned on, attach the full amenity list for each rental.",
                        "default": false
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop the run once this many rentals have been gathered.",
                        "default": 40
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up. Bump it up if you run into timeout errors.",
                        "default": 75
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
