# Storage.com Self-Storage Facility Scraper (`crawlerbros/storage-com-scraper`) Actor

Scrape Storage.com self-storage facility listings by city, ZIP code, or state - name, address, phone, starting price, unit sizes and pricing, amenities, ratings, reviews, and hours.

- **URL**: https://apify.com/crawlerbros/storage-com-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Real estate
- **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

## Storage.com Self-Storage Facility Scraper

Scrape **Storage.com** — the nationwide self-storage facility comparison directory covering all 50 US states. Search facilities by city, ZIP code, or state, browse the full list of cities a state covers, or pull deep detail (phone number, office/gate hours, unit-by-unit pricing, and Google review text) for specific facility pages by URL. HTTP-only, no login, no cookies, no API key required.

### What this actor does

- **Five modes:** `city`, `zip`, `state`, `citiesByState`, `facilityDetail`
- **City / ZIP / state search:** returns storage facilities with address, phone, starting price, ratings, and amenities
- **Facility detail lookup:** fetches office hours, gate-access hours, full unit-size and per-unit pricing breakdown, and sample Google reviews for a specific facility page
- **Filters:** amenities (climate controlled, drive-up access, 24-hour access, and more), unit size, sort order
- **State directory:** list every city Storage.com covers within a state
- **Empty fields are omitted** — a field is only present when real data was found

### Output per facility (`recordType: "facility"`)

- `facilityId`, `name`, `facilityType`
- `address`, `streetAddress`, `city`, `state`, `fullState`, `zip`
- `latitude`, `longitude`, `distanceMiles` (when searching by city/ZIP)
- `cityTotalFacilities` — Storage.com's total facility count for the searched city/ZIP market (not just the number of records this run emitted; city/ZIP/state search modes only)
- `zipSearchResolvedLocation` — the city/state Storage.com resolved a searched ZIP code to, e.g. `"Beverly Hills, CA"` for ZIP `90210` (mode=`zip` only)
- `phone`
- `facilityUrl` — canonical Storage.com facility page
- `imageUrls[]` — facility photos
- `mapImageUrl` — static map image
- `isOpenNow`, `onlineMoveInAvailable`, `bookableOnline`
- `startingPrice`, `lowestPrice`, `priceCurrency`
- `adminFee`, `lockFee`, `totalFees`
- `promoText`, `hasPromotion`, `militaryDiscount`, `studentDiscount`, `seniorDiscount`, `hasAaaDiscount`, `hasPenskeTruck`
- `rating`, `reviewCount` — Storage.com's own review aggregate
- `googleRating`, `googleReviewCount`, `googleReviewsSample[]` — Google review aggregate and up to a handful of individual reviews (author, rating, text, relative time, review date), when the facility has Google reviews enabled
- `unitsAvailable`
- `unitPricing[]` — per-unit-size breakdown: `size`, `squareFootage`, `widthFeet`, `lengthFeet`, `price`, `regularPrice` (when discounted), `special`, `amenities[]`, `unitType`, `unitsOfThisTypeAvailable` (when published), `reservationUrl` (direct booking deep link for that specific unit)
- `hasClimateControlledUnits`, `hasDriveUpUnits`
- `amenities[]` — facility-level amenities (video surveillance, electronic gate access, 24-hour access, etc.)
- `paymentMethods[]`, `autoPayAvailable`, `acceptedCreditCards[]`
- `officeHours{}`, `accessHours{}` — per weekday, when published
- `holidayClosures[]` — upcoming closure dates, when published
- `description`
- `recordType: "facility"`, `scrapedAt`

### Output per city (`recordType: "city"`, mode=`citiesByState`)

- `city`, `state`, `fullState`, `cityUrl`

### Output for invalid input (`recordType: "error"`)

- `errorType`, `message`, plus the offending input field for traceability

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `city` | `city` / `zip` / `state` / `citiesByState` / `facilityDetail` |
| `state` | string | `texas` | US state (mode=city, mode=state, mode=citiesByState) |
| `city` | string | `Austin` | City name within the selected state (mode=city) |
| `zipCode` | string | – | 5-digit US ZIP code (mode=zip) |
| `facilityUrls` | array | – | Full Storage.com facility page URLs (mode=facilityDetail) |
| `amenities` | array | – | Filter to facilities with ALL selected amenities |
| `unitSize` | string | – | Filter to facilities offering a specific unit size |
| `sortBy` | string | `recommended` | `recommended` / `price` / `distance` / `reviews` / `rating` / `relevance` |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–2000) |

### Examples

#### Example: search a city with amenity and size filters

```json
{
  "mode": "city",
  "state": "california",
  "city": "Los Angeles",
  "amenities": ["climateControlled", "twentyFourHourAccess"],
  "unitSize": "76-100",
  "sortBy": "price",
  "maxItems": 50
}
````

#### Example: search near a ZIP code

```json
{
  "mode": "zip",
  "zipCode": "10001",
  "maxItems": 30
}
```

#### Example: browse every facility in a state

```json
{
  "mode": "state",
  "state": "wyoming",
  "maxItems": 200
}
```

#### Example: list every city a state covers

```json
{
  "mode": "citiesByState",
  "state": "florida",
  "maxItems": 500
}
```

#### Example: full detail for specific facilities

```json
{
  "mode": "facilityDetail",
  "facilityUrls": [
    "https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/"
  ]
}
```

### Use cases

- **Price comparison tools** — aggregate starting prices and unit-size pricing across cities
- **Market research** — analyze self-storage supply, amenities, and pricing by state or metro
- **Lead generation** — build contact lists of self-storage operators with phone numbers and addresses
- **Local SEO / directory sites** — enrich a self-storage directory with fresh facility data
- **Real estate & site-selection analysis** — gauge self-storage density and pricing in a target market

### FAQ

**What is the data source?**
Storage.com, a self-storage facility search and comparison directory covering all 50 US states. This actor is an independent, third-party scraper — it is not affiliated with or endorsed by Storage.com.

**Do I need a login, cookie, or API key?**
No. Every mode works with a plain input — no authentication of any kind.

**How does ZIP code search work?**
The actor searches Storage.com's own ZIP-proximity endpoint directly (`/self-storage/zip/{zip}/`), which returns facilities ranked by actual distance to that ZIP rather than the whole containing city. If that endpoint has no coverage for a given ZIP, the actor automatically falls back to resolving the ZIP to its city/state and searching that city's page instead. If neither path finds coverage, the actor returns a typed error record explaining why instead of failing silently.

**Why do some facilities have fewer fields than others?**
Fields are only included when Storage.com actually published that data for the facility. Phone number, office hours, and full unit-by-unit pricing are richest on `facilityDetail` mode; `city`/`zip`/`state` search results include a smaller representative sample of unit prices per facility (small / medium / large).

**Why is `googleReviewsSample` sometimes missing?**
Not every facility has Google Reviews integration enabled on Storage.com. When it is, up to a handful of the most relevant reviews are included with author, rating, text, and date.

**What does `unitSize` filter on?**
Storage.com's own unit-size buckets (5'x5' through 10'x30'). Facilities are only returned if they currently list an available unit within that size range.

**What is `cityTotalFacilities`?**
Storage.com's own reported total facility count for the searched city/ZIP market — useful as market-size context alongside the (possibly smaller, `maxItems`-capped) set of records this run actually returned. Only present on `city`/`zip`/`state` search modes, not `facilityDetail`.

**How current is the data?**
Every run fetches live pages directly from storage.com at request time — pricing and availability reflect what the site shows at that moment.

**Is the phone number always the facility's own number?**
In `city`, `zip`, and `state` search results, yes — it's the facility's own listed number. On `facilityDetail` lookups, Storage.com occasionally serves a shared call-tracking number instead of the facility's direct line (this is Storage.com's own call-attribution system, not something this actor controls); calling it still reaches the facility. If you need the guaranteed facility-specific number, cross-reference the same facility's `city`/`zip`/`state` search result.

**Does `sortBy=price` guarantee strictly ascending prices?**
The `sortBy` parameter is sent directly to Storage.com's own search ranking, and results reflect exactly what storage.com itself returns for that sort — the actor does not re-sort results locally. On Storage.com, `price` sort is blended with other ranking signals (e.g. sponsored/recommended placement) rather than a pure ascending sort, the same behavior you'd see browsing the site directly.

**Does `mode=state` return every facility in the state in one run?**
It sweeps every city Storage.com lists for that state, in order, until `maxItems` is reached or every city has been checked. For large states this can be a long-running search — set `maxItems` to the number of facilities you actually need to keep runs fast.

# Actor input Schema

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

What to fetch.

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

US state to search (mode=city, mode=state, mode=citiesByState).

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

City name within the selected state (mode=city), e.g. `Austin`, `Los Angeles`, `New York`.

## `zipCode` (type: `string`):

5-digit US ZIP code to search near (mode=zip). Resolved to the matching Storage.com city page.

## `facilityUrls` (type: `array`):

Full Storage.com facility page URLs to fetch full detail for (phone, hours, unit-level pricing, reviews). e.g. `https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/`

## `amenities` (type: `array`):

Only return facilities with ALL selected amenities (mode=city, mode=zip, mode=state).

## `unitSize` (type: `string`):

Only return facilities offering this unit size (mode=city, mode=zip, mode=state).

## `sortBy` (type: `string`):

Result order (mode=city, mode=zip, mode=state).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "city",
  "state": "texas",
  "city": "Austin",
  "zipCode": "78735",
  "facilityUrls": [
    "https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/"
  ],
  "amenities": [],
  "unitSize": "",
  "sortBy": "recommended",
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped Storage.com self-storage facilities and city listings.

# 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": "city",
    "state": "texas",
    "city": "Austin",
    "zipCode": "78735",
    "facilityUrls": [
        "https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/"
    ],
    "amenities": [],
    "unitSize": "",
    "sortBy": "recommended",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/storage-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": "city",
    "state": "texas",
    "city": "Austin",
    "zipCode": "78735",
    "facilityUrls": ["https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/"],
    "amenities": [],
    "unitSize": "",
    "sortBy": "recommended",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/storage-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": "city",
  "state": "texas",
  "city": "Austin",
  "zipCode": "78735",
  "facilityUrls": [
    "https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/"
  ],
  "amenities": [],
  "unitSize": "",
  "sortBy": "recommended",
  "maxItems": 20
}' |
apify call crawlerbros/storage-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Storage.com Self-Storage Facility Scraper",
        "description": "Scrape Storage.com self-storage facility listings by city, ZIP code, or state - name, address, phone, starting price, unit sizes and pricing, amenities, ratings, reviews, and hours.",
        "version": "1.0",
        "x-build-id": "PEbxtqW3NUPEy53uI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~storage-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-storage-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~storage-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-storage-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~storage-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-storage-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": [
                            "city",
                            "zip",
                            "state",
                            "citiesByState",
                            "facilityDetail"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "city"
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "alabama",
                            "alaska",
                            "arizona",
                            "arkansas",
                            "california",
                            "colorado",
                            "connecticut",
                            "delaware",
                            "florida",
                            "georgia",
                            "hawaii",
                            "idaho",
                            "illinois",
                            "indiana",
                            "iowa",
                            "kansas",
                            "kentucky",
                            "louisiana",
                            "maine",
                            "maryland",
                            "massachusetts",
                            "michigan",
                            "minnesota",
                            "mississippi",
                            "missouri",
                            "montana",
                            "nebraska",
                            "nevada",
                            "new-hampshire",
                            "new-jersey",
                            "new-mexico",
                            "new-york",
                            "north-carolina",
                            "north-dakota",
                            "ohio",
                            "oklahoma",
                            "oregon",
                            "pennsylvania",
                            "rhode-island",
                            "south-carolina",
                            "south-dakota",
                            "tennessee",
                            "texas",
                            "utah",
                            "vermont",
                            "virginia",
                            "washington",
                            "west-virginia",
                            "wisconsin",
                            "wyoming"
                        ],
                        "type": "string",
                        "description": "US state to search (mode=city, mode=state, mode=citiesByState).",
                        "default": "texas"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name within the selected state (mode=city), e.g. `Austin`, `Los Angeles`, `New York`.",
                        "default": "Austin"
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "pattern": "^$|^[0-9]{5}$",
                        "type": "string",
                        "description": "5-digit US ZIP code to search near (mode=zip). Resolved to the matching Storage.com city page.",
                        "default": ""
                    },
                    "facilityUrls": {
                        "title": "Facility URLs (mode=facilityDetail)",
                        "type": "array",
                        "description": "Full Storage.com facility page URLs to fetch full detail for (phone, hours, unit-level pricing, reviews). e.g. `https://www.storage.com/self-storage/texas/austin/extra-space-storage-8990-austin-boston-lane-232554/`",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "amenities": {
                        "title": "Amenity filters",
                        "type": "array",
                        "description": "Only return facilities with ALL selected amenities (mode=city, mode=zip, mode=state).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hasOnlineMoveins",
                                "alarm",
                                "climateControlled",
                                "driveUp",
                                "firstFloor",
                                "twentyFourHourAccess",
                                "freeTruckRental",
                                "openNow"
                            ],
                            "enumTitles": [
                                "Online move-in available",
                                "Alarm",
                                "Climate controlled",
                                "Drive-up access",
                                "1st floor",
                                "24-hour access",
                                "Free truck rental",
                                "Open now"
                            ]
                        },
                        "default": []
                    },
                    "unitSize": {
                        "title": "Unit size filter",
                        "enum": [
                            "",
                            "0-25",
                            "26-60",
                            "61-75",
                            "76-100",
                            "101-150",
                            "151-200",
                            "201-250",
                            "251-300"
                        ],
                        "type": "string",
                        "description": "Only return facilities offering this unit size (mode=city, mode=zip, mode=state).",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "recommended",
                            "price",
                            "distance",
                            "reviews",
                            "rating",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Result order (mode=city, mode=zip, mode=state).",
                        "default": "recommended"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
