# SelfStorage.com Scraper (`crawlerbros/selfstorage-com-scraper`) Actor

Scrape SelfStorage.com - find self-storage facilities for rent by city, ZIP code, or address. Get facility names, addresses, unit sizes, prices, ratings, and amenities like climate control and drive-up access. No login required.

- **URL**: https://apify.com/crawlerbros/selfstorage-com-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## SelfStorage.com Scraper

Scrape **SelfStorage.com** — a self-storage unit rental marketplace covering thousands of facilities across the United States. Search by city, ZIP code, or address to get facility names, addresses, unit sizes, monthly prices, ratings, and amenities like climate control, drive-up access, and 24-hour gate entry. No login required — SelfStorage.com lets you reserve a unit for free with no credit card, and the same public search results are what this actor reads.

### What this actor does

- **Two modes:** `search` (find facilities near a location) and `facilityDetail` (full details for one facility)
- **Search by location:** city + state, a 5-digit ZIP code, or a street address (the city/state portion is used)
- **Unit size filter:** small, medium, large, extra-large, or vehicle/RV/boat storage
- **Amenity filter:** climate control, drive-up access, 24-hour access, truck rental, video surveillance, discounts, billing options, and more — match facilities that have ALL of the amenities you select
- **Real, live pricing** for representative small/medium/large units at every facility, including current specials
- **Facility detail mode** returns every unit at a facility (not just 3 representative ones), real customer reviews, full weekly office/access hours, and extra amenities (like 24-hour kiosk service) only published on the facility's own page
- **Empty fields are omitted** — you'll never see `null`, `""`, or `[]` in the output

### Output per facility (mode=search)

- `facilityId`, `name`, `phone`
- `streetAddress`, `city`, `state`, `zip`, `latitude`, `longitude`
- `distanceMiles` — distance from the searched location
- `rating`, `reviewCount`
- `lowestPriceUsd` — cheapest advertised unit at this facility
- `unitsAvailable`
- `adminFeeUsd`, `lockFeeUsd`, `totalFeesUsd`
- `isOpenNow`, `acceptsOnlineMoveIn`
- `officeHours`, `accessHours` — weekly schedule per day (e.g. `{"Monday": "9:30 AM-6:00 PM", "Sunday": "Closed"}`)
- `acceptedPaymentMethods[]` — e.g. `Visa`, `Mastercard`, `Cash`, `Checks`
- `amenities[]` — matched feature keys (see Input table for the full list)
- `units[]` — representative units, each with:
  - `sizeText` (e.g. `10' x 10'`), `squareFootage`, `sizeCategory`
  - `priceMonthlyUsd`, `quantityAvailable`, `specialOffer`
  - `unitType`, `vehicleAccommodation` (for RV/boat/car storage)
  - `unitAmenities[]`, `reserveUrl` (free, no-credit-card reservation link)
- `facilityUrl` — canonical SelfStorage.com facility page
- `imageUrl`, `imageUrls[]` — facility photos
- `recordType: "facility"`, `scrapedAt`

### Output per facility (mode=facilityDetail)

Everything above, plus:
- `units[]` — **every** unit at the facility (not capped to 3)
- `reviews[]` — real customer reviews: `{ reviewerName, rating, message, date }`
- `amenities[]` — includes detail-page-only features: `kiosk`, `acceptsMailForTenants`, `movingSuppliesForSale`, `residentManagerOnSite`, `insuranceRequired`, `insuranceAvailable`, `homeownersInsuranceAccepted`, `remotePaperworkAvailable`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` (find facilities) or `facilityDetail` (full detail for one facility) |
| `location` | string | `Austin, TX` | (mode=search) City + state, a 5-digit ZIP code, or a street address ending in city + state |
| `facilityUrl` | string | – | (mode=facilityDetail) A SelfStorage.com facility URL, e.g. the `facilityUrl` field from a `search` result |
| `unitSizeCategory` | select | `any` | (mode=search) `any` / `small` / `medium` / `large` / `extraLarge` / `vehicle` |
| `features` | array (select) | – | (mode=search) Amenities the facility must ALL have — see full enum in the input schema (climate control, drive-up access, 24-hour access, truck rental, discounts, billing options, vehicle parking type, etc.) |
| `maxItems` | int | `30` | (mode=search) Maximum number of facilities to return (1–500) |
| `proxyConfiguration` | proxy | AUTO | Optional. The free Apify datacenter proxy works fine; a proxy is not required for this site |

#### Example: search by city and state

```json
{
  "location": "Austin, TX",
  "maxItems": 30
}
````

#### Example: search by ZIP code, climate-controlled only

```json
{
  "location": "78748",
  "features": ["climateControlled"],
  "maxItems": 20
}
```

#### Example: large units with drive-up access

```json
{
  "location": "Los Angeles, CA",
  "unitSizeCategory": "large",
  "features": ["driveUpAccess"],
  "maxItems": 50
}
```

#### Example: RV / boat / vehicle storage

```json
{
  "location": "Austin, TX",
  "unitSizeCategory": "vehicle",
  "maxItems": 25
}
```

#### Example: full detail for one facility

```json
{
  "mode": "facilityDetail",
  "facilityUrl": "https://www.selfstorage.com/self-storage/texas/austin/cubesmart-self-storage-austin-10025-manchaca-rd-63544/"
}
```

### Use cases

- **Moving & relocation platforms** — surface nearby storage options alongside moving quotes
- **Price comparison sites** — track self-storage rates across cities and unit sizes
- **Local market research** — analyze storage facility density, pricing, and amenities by metro area
- **RV/boat owners** — find vehicle storage with the right coverage (covered/uncovered/enclosed)
- **Real estate & relocation services** — bundle storage recommendations for clients moving between cities

### Data source / limitations

- Data comes from SelfStorage.com's public search pages — no login, cookies, or paid API required.
- `location` accepts a 5-digit US ZIP code (resolved to city/state via the free, keyless [Zippopotam.us](https://zippopotam.us) API) or a `City, ST` / `City, State` string. A bare city name without a state cannot be resolved reliably and will return a clear "could not determine state" status message instead of a guess.
- This actor covers the United States only, matching SelfStorage.com's own coverage.
- Amenity data reflects what SelfStorage.com publishes for each facility; some smaller or newly-listed facilities may have fewer amenities populated upstream.
- In `mode=search`, `unitSizeCategory` matches against up to 3 representative units per facility (chosen by SelfStorage.com itself, not by this actor). Common sizes (`small`/`medium`/`large`) are almost always covered, but `extraLarge` and `vehicle` are only picked up when the site happens to select one of those as a facility's representative unit — so these two values can return few or zero results in `search` mode even in cities where such units exist. For guaranteed, complete unit-size coverage (including every vehicle/RV/boat space), use `mode=facilityDetail` on a specific facility, which returns its full unit list.

### FAQ

**Is this affiliated with SelfStorage.com?**
No. This is an independent, third-party actor that reads SelfStorage.com's public search results. It is not affiliated with, endorsed by, or sponsored by SelfStorage.com.

**Do I need an account or cookies?**
No. All data returned by this actor is visible on SelfStorage.com's public search pages without logging in.

**Why do some facilities have fewer than 3 units listed?**
The actor reports up to 3 representative units (small/medium/large, deduplicated) as advertised by SelfStorage.com's own search result page for that facility — not necessarily every unit at the facility.

**Can I filter by multiple amenities at once?**
Yes. `features` accepts multiple values; only facilities matching ALL selected amenities are returned.

**Does `unitSizeCategory: vehicle` include RVs, boats, and cars?**
Yes — it matches any facility with at least one parking-type unit (indoor or outdoor, covered or uncovered).

**How current is the pricing?**
Prices are read live from SelfStorage.com at the time the actor runs and reflect the same rates shown to site visitors, including current specials.

**Is a proxy required?**
No. This site is reliably reachable from Apify's free datacenter (AUTO) proxy, and even without any proxy at all.

**What happens if my location doesn't match any facilities?**
The actor finishes successfully with 0 records and a clear status message — it will not error or crash.

**How do I get every unit and real reviews for one facility?**
Use `mode: "facilityDetail"` with the `facilityUrl` from a `search` result (or any valid SelfStorage.com facility URL). It returns one record with the complete unit list and real customer reviews.

# Actor input Schema

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

`search` finds facilities near a location; `facilityDetail` fetches full details (every unit, real customer reviews, weekly hours) for one facility.

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

(mode=search) City and state (recommended, e.g. `Austin, TX` or `Austin, Texas`), or a 5-digit US ZIP code (e.g. `78748`). A full street address also works as long as it ends with a city and state.

## `facilityUrl` (type: `string`):

(mode=facilityDetail) A SelfStorage.com facility URL — e.g. the `facilityUrl` field from a `search` result, such as `https://www.selfstorage.com/self-storage/texas/austin/cubesmart-self-storage-austin-10025-manchaca-rd-63544/`.

## `unitSizeCategory` (type: `string`):

(mode=search) Only return facilities that have at least one available unit in this size category.

## `features` (type: `array`):

(mode=search) Only return facilities that have ALL of the selected amenities. Leave empty to skip this filter.

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

(mode=search) Maximum number of facilities to return.

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

Optional proxy. The free Apify datacenter proxy (AUTO) works fine for this site; a proxy is not required.

## Actor input object example

```json
{
  "mode": "search",
  "location": "Austin, TX",
  "unitSizeCategory": "any",
  "features": [],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `facilities` (type: `string`):

Dataset containing all scraped self-storage facilities.

# 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 = {
    "mode": "search",
    "location": "Austin, TX",
    "unitSizeCategory": "any",
    "features": [],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/selfstorage-com-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 = {
    "mode": "search",
    "location": "Austin, TX",
    "unitSizeCategory": "any",
    "features": [],
    "maxItems": 30,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/selfstorage-com-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 '{
  "mode": "search",
  "location": "Austin, TX",
  "unitSizeCategory": "any",
  "features": [],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/selfstorage-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SelfStorage.com Scraper",
        "description": "Scrape SelfStorage.com - find self-storage facilities for rent by city, ZIP code, or address. Get facility names, addresses, unit sizes, prices, ratings, and amenities like climate control and drive-up access. No login required.",
        "version": "1.0",
        "x-build-id": "m8Ecm6N3NFXFuehOg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~selfstorage-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-selfstorage-com-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~selfstorage-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-selfstorage-com-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~selfstorage-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-selfstorage-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "facilityDetail"
                        ],
                        "type": "string",
                        "description": "`search` finds facilities near a location; `facilityDetail` fetches full details (every unit, real customer reviews, weekly hours) for one facility.",
                        "default": "search"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "(mode=search) City and state (recommended, e.g. `Austin, TX` or `Austin, Texas`), or a 5-digit US ZIP code (e.g. `78748`). A full street address also works as long as it ends with a city and state.",
                        "default": "Austin, TX"
                    },
                    "facilityUrl": {
                        "title": "Facility URL",
                        "type": "string",
                        "description": "(mode=facilityDetail) A SelfStorage.com facility URL — e.g. the `facilityUrl` field from a `search` result, such as `https://www.selfstorage.com/self-storage/texas/austin/cubesmart-self-storage-austin-10025-manchaca-rd-63544/`."
                    },
                    "unitSizeCategory": {
                        "title": "Unit size category",
                        "enum": [
                            "any",
                            "small",
                            "medium",
                            "large",
                            "extraLarge",
                            "vehicle"
                        ],
                        "type": "string",
                        "description": "(mode=search) Only return facilities that have at least one available unit in this size category.",
                        "default": "any"
                    },
                    "features": {
                        "title": "Amenities / features",
                        "type": "array",
                        "description": "(mode=search) Only return facilities that have ALL of the selected amenities. Leave empty to skip this filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "climateControlled",
                                "driveUpAccess",
                                "groundFloor",
                                "elevatorAccess",
                                "twentyFourHourAccess",
                                "truckRentalAvailable",
                                "freeTruckRental",
                                "truckAccess",
                                "videoSurveillance",
                                "fencedAndLighted",
                                "handcartsAvailable",
                                "eGateKeypadAccess",
                                "penskeTruckRental",
                                "bandPracticeAllowed",
                                "militaryDiscount",
                                "studentDiscount",
                                "seniorDiscount",
                                "aaaDiscount",
                                "onlineMoveIn",
                                "currentSpecialOffer",
                                "vehicleStorage",
                                "coveredVehicleParking",
                                "uncoveredVehicleParking",
                                "enclosedVehicleStorage",
                                "emailInvoicingAvailable",
                                "autoPayAvailable",
                                "securityDepositRequired",
                                "cashAccepted",
                                "checksAccepted"
                            ],
                            "enumTitles": [
                                "Climate controlled",
                                "Drive-up access",
                                "Ground floor unit",
                                "Elevator access",
                                "24-hour access",
                                "Truck rental available",
                                "Free truck rental",
                                "Truck access (large vehicles)",
                                "Video surveillance",
                                "Fenced and lighted",
                                "Handcarts available",
                                "E-gate / keypad access",
                                "Penske truck rental",
                                "Band practice allowed",
                                "Military discount",
                                "Student discount",
                                "Senior discount",
                                "AAA discount",
                                "Online move-in",
                                "Current special offer",
                                "Vehicle storage available",
                                "Covered vehicle parking",
                                "Uncovered vehicle parking",
                                "Enclosed vehicle storage",
                                "Email invoicing available",
                                "Auto-pay available",
                                "Security deposit required",
                                "Cash accepted",
                                "Checks accepted"
                            ]
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max facilities",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "(mode=search) Maximum number of facilities to return.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The free Apify datacenter proxy (AUTO) works fine for this site; a proxy is not required.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
