# RentCafe Scraper (`solidcode/rentcafe-scraper`) Actor

\[💰 $2.5 / 1K] Extract US apartment and rental listings from RentCafe. Get prices, addresses, geo coordinates, floorplans, beds, baths, sqft, amenities, photos, and leasing contacts. Search by city, state, or ZIP, or paste RentCafe URLs.

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

## Pricing

from $2.50 / 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.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

## RentCafe Scraper

Pull US apartment and rental listings from RentCafe at scale — rent ranges, floorplans with per-bedroom starting prices, structured addresses with latitude/longitude, amenities, photo galleries, star ratings, and verified leasing contacts for every apartment community. Built for rental-market analysts, relocation and PropTech platforms, and multifamily lead-generation teams who need clean, structured RentCafe data without copy-pasting listings by hand.

### Why This Scraper?

- **Latitude and longitude on every property** — each community ships map-ready geo coordinates, so listings drop straight onto a map or into a radius query with no geocoding step.
- **Structured floorplan array with per-bedroom starting rents** — every property carries a `floorplans` list where each entry pairs a bedroom label ("Studio", "1 Bed", "2 Beds") with its starting rent as both a display string and a parsed number.
- **Verified leasing phone + online-leasing URL** — the leasing office phone and the direct apply/lease-online link come attached to each row, ready for outreach or handoff.
- **Star ratings with review counts** — the resident rating and the number of reviews behind it land on every property for reputation filtering and ranking.
- **True photo gallery counts, not just previews** — `photosCount` reports the full gallery size (often 20–70 images) alongside a set of preview photo URLs and a `hasVideo` flag.
- **Rent parsed into `priceMin` and `priceMax`** — the human "$1,114 – $1,685" range is kept and also split into clean numeric min/max fields you can sort and filter on directly.
- **Search 50 US states by "City, ST" or ZIP — or paste a URL** — type "Austin, TX" or "78701" and the actor builds the RentCafe search for you; any price, bedroom, or amenity filter already in a pasted URL is applied automatically.
- **Batch many cities and URLs in one run** — queue a whole list of locations and search URLs in a single invocation and get every community in one dataset, deduplicated by property.
- **Availability and freshness signals** — `unitsAvailable`, a verified-listing flag, and a last-updated marker show which communities are actively renting right now.

### Use Cases

**Rental Market Research**
- Map median and range rents by city, neighborhood, or ZIP
- Compare price-per-bedroom across submarkets using the floorplan array
- Track available-unit counts to gauge supply and vacancy pressure
- Benchmark amenity offerings across competing communities

**Relocation & PropTech**
- Power apartment-search and relocation tools with map-ready geo coordinates
- Build "communities near me" experiences from latitude/longitude
- Feed rent ranges and floorplans into affordability calculators
- Surface actively-renting communities with available units for movers

**Lead Generation**
- Build leasing-office contact lists with property name, phone, and apply link
- Target management companies operating in specific metros
- Assemble outreach lists for vendors selling into multifamily operators
- Route verified listings with open units straight into a CRM

**Investment & Competitive Analysis**
- Compare a property's rents against nearby communities for underwriting
- Track star ratings and review counts as a reputation signal
- Monitor rent movements over repeated runs on the same searches
- Identify management companies expanding into a target market

### Getting Started

#### Search by City or ZIP

The simplest way to start — just type a location, no URL required:

```json
{
    "searchLocations": ["Austin, TX"],
    "maxResults": 50
}
````

#### Paste a Filtered RentCafe URL

Any filters already in the URL — price, bedrooms, property type — are applied automatically:

```json
{
    "startUrls": [
        "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/?PriceMin=1000&PriceMax=2000"
    ],
    "maxResults": 100
}
```

#### Multi-City Batch

Mix locations and URLs, cap the run, and drop floorplans for a lighter result:

```json
{
    "searchLocations": ["Dallas, TX", "78701"],
    "startUrls": [
        "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"
    ],
    "maxResults": 500,
    "includeFloorplans": false
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `["https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"]` | Paste RentCafe search-result URLs. Any filters already in the URL — price, bedrooms, property type, location — are applied automatically. Add as many URLs as you like to scrape several searches in one run. |
| `searchLocations` | array | `[]` | Search by typing a city and state (for example "Austin, TX") or a ZIP code (for example "78701"). No need to build a URL yourself — the scraper finds the matching RentCafe search for you. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of properties to return across all URLs and searches. Set to 0 for unlimited. Start with 10–50 to test, then increase. |
| `includeFloorplans` | boolean | `true` | Include the list of floorplans for each property (bedrooms and starting rent). Turn this off for a lighter result with just the overall price range. |

### Output

Each result is one apartment community, with its floorplans nested inside:

```json
{
    "propertyId": "1234567",
    "name": "The Maxwell Apartments",
    "companyName": "Greystar",
    "description": "Modern apartment living in the heart of downtown with resort-style amenities.",
    "url": "https://www.rentcafe.com/apartments/az/phoenix/the-maxwell/default.aspx",
    "onlineLeasingUrl": "https://www.rentcafe.com/onlineleasing/the-maxwell/apply.aspx",
    "phone": "(602) 555-0142",
    "address": {
        "street": "125 N Central Ave",
        "city": "Phoenix",
        "state": "AZ",
        "zip": "85004"
    },
    "addressFormatted": "125 N Central Ave, Phoenix, AZ 85004",
    "latitude": 33.4515,
    "longitude": -112.0740,
    "priceRange": "$1,114 - $1,685",
    "priceMin": 1114,
    "priceMax": 1685,
    "beds": "Studio - 2 Beds",
    "baths": "1 - 2",
    "area": "520 - 1,050 Sq Ft",
    "amenities": ["Pool", "Fitness Center", "In-Unit Laundry", "Covered Parking"],
    "photos": ["https://cdn.rentcafe.com/the-maxwell/photo-1.jpg"],
    "photosCount": 34,
    "hasVideo": true,
    "starRating": 4.5,
    "reviewsCount": 128,
    "unitsAvailable": 12,
    "unitsAvailableLabel": "12 Units available",
    "verifiedListing": true,
    "isFavorite": false,
    "lastUpdatedDate": "Today",
    "searchUrl": "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/",
    "floorplans": [
        { "beds": "Studio", "rent": "$1,114", "rentValue": 1114 },
        { "beds": "1 Bed", "rent": "$1,340", "rentValue": 1340 },
        { "beds": "2 Beds", "rent": "$1,685", "rentValue": 1685 }
    ]
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `propertyId` | string | Unique RentCafe property identifier |
| `name` | string | Apartment community name |
| `companyName` | string | Management company display name |
| `description` | string | Marketing description of the community |
| `url` | string | RentCafe property detail page URL |
| `onlineLeasingUrl` | string | Direct online leasing / apply URL |
| `phone` | string | Leasing office phone number |
| `searchUrl` | string | The search URL or location this property came from |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | object | Structured address: `street`, `city`, `state`, `zip` |
| `addressFormatted` | string | Full single-line address |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Pricing & Size

| Field | Type | Description |
|-------|------|-------------|
| `priceRange` | string | Rent range as displayed, e.g. "$1,114 - $1,685" |
| `priceMin` | number | Minimum rent, parsed to a number |
| `priceMax` | number | Maximum rent, parsed to a number |
| `beds` | string | Bedroom range, e.g. "Studio - 2 Beds" |
| `baths` | string | Bathroom range |
| `area` | string | Square-footage range |

#### Floorplans, Media & Amenities

| Field | Type | Description |
|-------|------|-------------|
| `floorplans` | object\[] | Nested floorplans, each with `beds`, `rent` (display string), and `rentValue` (parsed number). Present when `includeFloorplans` is on |
| `amenities` | string\[] | Human-readable amenity labels |
| `photos` | string\[] | Preview photo gallery image URLs |
| `photosCount` | integer | Full photo gallery size |
| `hasVideo` | boolean | Whether the property has video |

#### Ratings & Availability

| Field | Type | Description |
|-------|------|-------------|
| `starRating` | number | Average resident star rating |
| `reviewsCount` | integer | Number of resident reviews |
| `unitsAvailable` | integer | Number of available units, parsed to a number |
| `unitsAvailableLabel` | string | Available-units text as displayed, e.g. "12 Units available" |
| `verifiedListing` | boolean | Verified-listing flag |
| `isFavorite` | boolean | Whether the listing is marked as a favorite |
| `lastUpdatedDate` | string | When the listing was last updated, e.g. "Today" |

### Tips for Best Results

- **Start small** — set `maxResults` to 10–50 on your first run to confirm the data matches your needs, then scale up.
- **Type a location instead of building a URL** — "Austin, TX" or "78701" is faster and more reliable than hand-crafting a RentCafe search link.
- **Embed filters directly in a pasted URL** — apply the price and bedroom filters on RentCafe first, then paste that finished URL; every `PriceMin`, `PriceMax`, and bedroom filter in it carries straight through.
- **Use a ZIP for precise micro-markets** — a ZIP code targets a single submarket far more tightly than a whole city, ideal for comps and neighborhood-level analysis.
- **Batch a whole metro at once** — drop several city URLs or locations into one run; results are deduplicated by property, so overlapping searches never double-count a community.
- **Turn off floorplans for lighter output** — set `includeFloorplans` to `false` when you only need the overall price range, addresses, and contacts.
- **Sort on `priceMin` / `priceMax`, not `priceRange`** — the numeric min/max fields sort and filter cleanly, while the display range is text meant for reading.

### Pricing

**From $2.50 per 1,000 results** — flat pay-per-result, no matter how many floorplans, photos, or amenities a community carries. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.265 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one apartment community row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate rental-market research, relocation services, and lead generation. You are responsible for complying with applicable laws and RentCafe's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose. Be mindful of fair housing regulations when using rental and location data.

# Actor input Schema

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

Paste RentCafe search-result URLs (for example a city or neighborhood apartments page). Any filters already in the URL — price, bedrooms, property type, location — are applied automatically. Add as many URLs as you like to scrape several searches in one run.

## `searchLocations` (type: `array`):

Search by typing a city and state (for example 'Austin, TX') or a ZIP code (for example '78701'). No need to build a URL yourself — the scraper finds the matching RentCafe search for you.

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

Maximum number of properties to return across all URLs and searches. Set to 0 for unlimited. Note: each individual search returns up to about 10,000 properties (RentCafe's own depth limit). Tip: start with 10-50 to test, then increase.

## `includeFloorplans` (type: `boolean`):

Include the list of floorplans for each property (each with the bedroom label and its starting rent). Turn this off for a lighter result with just the overall price range.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"
  ],
  "searchLocations": [],
  "maxResults": 100,
  "includeFloorplans": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped properties with key fields.

# 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 = {
    "startUrls": [
        "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"
    ],
    "searchLocations": [],
    "maxResults": 100,
    "includeFloorplans": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/rentcafe-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 = {
    "startUrls": ["https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"],
    "searchLocations": [],
    "maxResults": 100,
    "includeFloorplans": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/rentcafe-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 '{
  "startUrls": [
    "https://www.rentcafe.com/apartments-for-rent/us/az/phoenix/"
  ],
  "searchLocations": [],
  "maxResults": 100,
  "includeFloorplans": true
}' |
apify call solidcode/rentcafe-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RentCafe Scraper",
        "description": "[💰 $2.5 / 1K] Extract US apartment and rental listings from RentCafe. Get prices, addresses, geo coordinates, floorplans, beds, baths, sqft, amenities, photos, and leasing contacts. Search by city, state, or ZIP, or paste RentCafe URLs.",
        "version": "1.0",
        "x-build-id": "zkJpUKI32aru1YkP7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~rentcafe-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-rentcafe-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/solidcode~rentcafe-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-rentcafe-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/solidcode~rentcafe-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-rentcafe-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": {
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste RentCafe search-result URLs (for example a city or neighborhood apartments page). Any filters already in the URL — price, bedrooms, property type, location — are applied automatically. Add as many URLs as you like to scrape several searches in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "Search by typing a city and state (for example 'Austin, TX') or a ZIP code (for example '78701'). No need to build a URL yourself — the scraper finds the matching RentCafe search for you.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to return across all URLs and searches. Set to 0 for unlimited. Note: each individual search returns up to about 10,000 properties (RentCafe's own depth limit). Tip: start with 10-50 to test, then increase.",
                        "default": 100
                    },
                    "includeFloorplans": {
                        "title": "Include Floorplans",
                        "type": "boolean",
                        "description": "Include the list of floorplans for each property (each with the bedroom label and its starting rent). Turn this off for a lighter result with just the overall price range.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
