# Public Storage Rate Tracker (`marielise.dev/public-storage-rate-tracker`) Actor

Scrape live self-storage rental rates from Public Storage by US city. Get a competitor rate matrix: median price by unit size and climate class, price per sq ft, online-vs-street discounts, move-in promos, and rate changes since your last run. For renters, storage operators, and revenue managers.

- **URL**: https://apify.com/marielise.dev/public-storage-rate-tracker.md
- **Developed by:** [Marielise](https://apify.com/marielise.dev) (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 $40.00 / 1,000 facility scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Self-Storage Rate Intelligence

**Rate-shop your storage market in one click.** Enter a US city and get every nearby Public Storage facility's live unit rates, normalized into a competitive rate matrix: the median price for a 10x10, a 10x20 climate-controlled, or a parking space, who is cheapest, the price per square foot, the move-in promos running right now, and how far online rates sit below street price. Schedule it and the Actor also tells you exactly which competitor rates moved since your last run.

Storage pricing is a moving target. Operators run "rate shops" every week, revenue managers pay four figures a month to tools like StorTrack and Radius+, and site developers commission feasibility studies just to answer "what does storage rent for here?" This Actor gives you that answer on demand, as clean structured data, with no subscription.

### Who this is for

- **Storage facility operators & managers** benchmarking their rates against the biggest competitor in town before setting move-in specials.
- **Revenue managers & multi-site operators** who need a repeatable weekly rate feed instead of manually browsing competitor websites.
- **Developers, investors & REIT analysts** running feasibility and underwriting studies on a new market.
- **Proptech & revenue-management builders** who want a rate feed to plug into their own dashboards, models, or pricing engines.
- **Analysts & journalists** tracking storage pricing trends across cities.

### What you get

**A market summary record** with the headline answer: cheapest rate in the market, the competitive **rate matrix** (min / median / average / max price for every size and climate class), price per square foot, the **climate-control premium** (size-matched, so unit mix never skews it), promo prevalence, and the median **online-vs-street discount** the incumbent is advertising.

**One record per facility** with its address, geo coordinates, customer rating, phone, move-in promo, lowest live rate, and its full list of unit types. Every unit carries its size, square footage, climate flag, access type (drive-up, indoor, elevator), advertised online rate, posted street rate, price per square foot, and availability.

**A rate-change watch.** Because each run stores a snapshot per market, a scheduled run compares against the last one and reports every unit class whose rate moved, how many went up, how many were cut, and what appeared or disappeared. Turn a one-off scrape into a standing competitive alert by scheduling the Actor daily or weekly.

Exports include the structured dataset, a `storage_rates.csv` spreadsheet (one row per unit), a `REPORT.md` market report, and a full `OUTPUT.json`.

### How to use it

1. Enter a **City** and **State** (e.g. `Austin` / `TX`), or type `Austin, TX` in the single location field, or paste Public Storage location/facility URLs.
2. Set **Max facilities** (default 10) to control coverage vs cost.
3. Leave the proxy on **Residential** (recommended) and run it.
4. To track changes over time, **schedule** the Actor for the same market on a daily or weekly cadence.

### Example input

```json
{
  "city": "Austin",
  "state": "TX",
  "maxFacilities": 10,
  "scanFacilityPages": true,
  "includeAnalytics": true
}
````

### Data source & scope

This Actor reads live, publicly available rates from **Public Storage** (publicstorage.com), the largest self-storage operator in the United States and the price bellwether most independents benchmark against. It is US-only. It reads server-rendered pages over plain HTTP (no headless browser), so it is fast and light on proxy bandwidth. It does not log in, and it collects only publicly listed pricing.

### Pricing

This Actor uses **pay-per-event** pricing: you pay for the results you get, with no monthly subscription, so both a one-off feasibility study and a high-frequency weekly rate watch stay cost-effective.

### FAQ

**Does it need a Public Storage account or API key?** No. It reads public pages.

**Why residential proxies?** Public Storage is behind Cloudflare; residential IPs are challenged far less often. Datacenter IPs may be blocked.

**Can it track rate changes automatically?** Yes. Schedule it for a market and each run diffs against the previous snapshot for that market.

**Which currencies/countries?** US markets, USD.

**Why Public Storage specifically?** It is the national price leader with facilities in nearly every metro, which makes it the single most useful benchmark for a rate shop. It is also the most reliable public source to keep a scheduled watch running against.

# Actor input Schema

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

The city to rate-shop, e.g. 'Austin', 'San Antonio', 'Los Angeles'. Required unless you paste URLs below.

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

The US state as a full name ('Texas') or two-letter code ('TX'). Required with City.

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

Alternative to the separate City and State fields. Example: 'Austin, TX'.

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

Paste one or more Public Storage location pages (e.g. https://www.publicstorage.com/self-storage-tx-austin) or facility pages (…/5279.html). Overrides the City/State fields.

## `maxFacilities` (type: `integer`):

How many facilities in the market to scrape (affects runtime and cost).

## `scanFacilityPages` (type: `boolean`):

Open each facility's own page to collect its full range of unit sizes and features. Turn off for a faster, cheaper run that reads only the units shown on the market page.

## `nearLatLng` (type: `string`):

Optional. Your location as 'latitude,longitude' (e.g. '30.2672,-97.7431' for downtown Austin). When set, every facility gets a distanceMiles, results are sorted nearest-first, and the summary adds a 'nearest' pick. Leave blank to skip distance.

## `includeAnalytics` (type: `boolean`):

Generate the full rate matrix, climate premium, availability, and online-vs-street discount analysis in the summary record.

## `outputFormat` (type: `string`):

How much detail to write to the OUTPUT.json key-value export. The dataset always contains full records.

## `proxy` (type: `object`):

Public Storage sits behind Cloudflare, so residential proxies are strongly recommended for reliable results. Moving away from RESIDENTIAL raises the chance of being challenged.

## Actor input object example

```json
{
  "city": "Austin",
  "state": "TX",
  "maxFacilities": 10,
  "scanFacilityPages": true,
  "includeAnalytics": true,
  "outputFormat": "full",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `marketSummary` (type: `string`):

Headline market intelligence: quick take, cheapest rate, climate premium, promo prevalence, and rate changes vs the previous run

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

Every storage facility with its lowest live rate, availability, rating, and full unit list

## `report` (type: `string`):

Human-readable market intelligence report with the full rate matrix and rate-change table

## `csvExport` (type: `string`):

Every scraped unit as one spreadsheet row for building your own rate grid

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "city": "Austin",
    "state": "TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("marielise.dev/public-storage-rate-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "city": "Austin",
    "state": "TX",
}

# Run the Actor and wait for it to finish
run = client.actor("marielise.dev/public-storage-rate-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "city": "Austin",
  "state": "TX"
}' |
apify call marielise.dev/public-storage-rate-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Public Storage Rate Tracker",
        "description": "Scrape live self-storage rental rates from Public Storage by US city. Get a competitor rate matrix: median price by unit size and climate class, price per sq ft, online-vs-street discounts, move-in promos, and rate changes since your last run. For renters, storage operators, and revenue managers.",
        "version": "0.0",
        "x-build-id": "O0didltXvdIUTcbjZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marielise.dev~public-storage-rate-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marielise.dev-public-storage-rate-tracker",
                "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/marielise.dev~public-storage-rate-tracker/runs": {
            "post": {
                "operationId": "runs-sync-marielise.dev-public-storage-rate-tracker",
                "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/marielise.dev~public-storage-rate-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-marielise.dev-public-storage-rate-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "The city to rate-shop, e.g. 'Austin', 'San Antonio', 'Los Angeles'. Required unless you paste URLs below."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "The US state as a full name ('Texas') or two-letter code ('TX'). Required with City."
                    },
                    "location": {
                        "title": "Or: City, State in one field",
                        "type": "string",
                        "description": "Alternative to the separate City and State fields. Example: 'Austin, TX'."
                    },
                    "startUrls": {
                        "title": "Or: Paste Public Storage URLs",
                        "type": "array",
                        "description": "Paste one or more Public Storage location pages (e.g. https://www.publicstorage.com/self-storage-tx-austin) or facility pages (…/5279.html). Overrides the City/State fields.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxFacilities": {
                        "title": "Max facilities",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many facilities in the market to scrape (affects runtime and cost).",
                        "default": 10
                    },
                    "scanFacilityPages": {
                        "title": "Deep scan each facility",
                        "type": "boolean",
                        "description": "Open each facility's own page to collect its full range of unit sizes and features. Turn off for a faster, cheaper run that reads only the units shown on the market page.",
                        "default": true
                    },
                    "nearLatLng": {
                        "title": "Sort by distance from (lat,lng)",
                        "type": "string",
                        "description": "Optional. Your location as 'latitude,longitude' (e.g. '30.2672,-97.7431' for downtown Austin). When set, every facility gets a distanceMiles, results are sorted nearest-first, and the summary adds a 'nearest' pick. Leave blank to skip distance."
                    },
                    "includeAnalytics": {
                        "title": "Include full analytics",
                        "type": "boolean",
                        "description": "Generate the full rate matrix, climate premium, availability, and online-vs-street discount analysis in the summary record.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output detail (for the JSON export)",
                        "enum": [
                            "full",
                            "summary_only",
                            "facilities_only"
                        ],
                        "type": "string",
                        "description": "How much detail to write to the OUTPUT.json key-value export. The dataset always contains full records.",
                        "default": "full"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Public Storage sits behind Cloudflare, so residential proxies are strongly recommended for reliable results. Moving away from RESIDENTIAL raises the chance of being challenged.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```