# ParkMe Parking Rate Scraper (`parseforge/parking-rate-scraper`) Actor

Scrapes parking rates from ParkMe by city or bounding box. Returns each lot with its address, operator, rate type, and calculated price for your chosen duration.

- **URL**: https://apify.com/parseforge/parking-rate-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 9 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### ParkMe Parking Rate Scraper

**Scrape parking rates from any city or bounding box on ParkMe, up to a million per run.** Every lot comes with its address, operator, rate type, and calculated price for your chosen duration. No API key required. Export to CSV, JSON, Excel, or XML.

Parking data is scattered across operator websites, each with its own format and no public API. This Actor reads the public ParkMe feed directly, searching by city name or a custom bounding box, and returns every matching parking lot with its rate for the duration you specify. You get a clean, flat dataset ready for analysis or integration.

| Who uses it | What they scrape ParkMe for |
|---|---|
| Mobility analysts | Compare parking costs across neighborhoods to understand urban accessibility. |
| Real estate developers | Assess local parking supply and pricing before acquiring a site. |
| Travel apps | Integrate real-time parking rates into trip planning features. |
| Data journalists | Investigate how parking prices correlate with public transit availability. |

### What it does

This Actor collects parking rates from ParkMe by city or geographic bounding box and returns each lot as a flat row with its address, operator, rate type, and calculated price.

- 📍 **City search:** provide a city and state, like "New York, NY", to get lots in that area.
- 🗺️ **Bounding box:** define a precise rectangle with swLat|swLng|neLat|neLng coordinates.
- ⏱️ **Duration control:** set parking duration from 1 minute to 24 hours for accurate pricing.
- 📅 **Entry time:** specify a future date and time to see rates for a planned trip.
- 🏷️ **Rate type:** choose Regular, Best Available, or Monthly rates.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with ParkMe data

**📊 Build a parking price heatmap.**

A mobility analyst runs the Actor for several bounding boxes across a metro area, exports the CSV, and maps average rates to identify pricing deserts.

**🏗️ Evaluate a development site.**

A real estate developer searches the city where they are considering a project, collects monthly rates, and compares them against projected building costs.

**🚗 Power a trip planner.**

A travel app team schedules a daily run for popular destinations, feeds the JSON into their backend, and shows users the cheapest nearby parking.

**📰 Report on urban affordability.**

A journalist scrapes rates for several cities, joins the data with census income figures, and publishes a story on parking cost burden.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Scrapes the public ParkMe feed with zero authentication. |
| **Flexible area** | Search by city or draw a custom bounding box. |
| **Accurate pricing** | Rates are calculated for your exact duration and entry time. |
| **Scalable** | Collect up to a million parking rates in a single run. |

### How it compares

No other Store actor targets ParkMe the same way, so the honest comparison is with the alternatives teams actually weigh.

| | ParkMe Parking Rate Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When ParkMe changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from a city name or a bounding box, set the parking duration and entry time, and choose the rate type so only matching lots reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "city": "New York, NY",
  "rateRequest": "R",
  "duration": 60,
  "entryTime": "2026-03-01T09:00"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "city": "New York, NY",
  "rateRequest": "R",
  "duration": 60,
  "entryTime": "2026-03-01T09:00"
}
```

### Pricing

Pay-per-result: **$0.001 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.10 |
| 1,000 results | $1.00 |
| 10,000 results | $10.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [ParkMe Parking Rate Scraper](https://apify.com/parseforge/parking-rate-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to ParkMe through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/parking-rate-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results for my city?**

Check the spelling and format. Use "City, ST" like "Chicago, IL". If the city name is ambiguous, try a bounding box instead.

**Why are some rates zero or missing?**

Not every lot publishes all rate types. Try switching from Regular to Best Available, or check if the lot offers Monthly rates.

**The bounding box returns lots outside my area.**

The bounding box is a rectangle. Tighten the coordinates or use a smaller range between the southwest and northeast corners.

**My run timed out.**

Large bounding boxes with high maxItems can take time. Reduce the area, lower maxItems, or increase the Actor's timeout setting.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape parking rates for a specific address? | The Actor searches by city or bounding box, not by street address. To target a specific location, draw a tight bounding box around it using the coordinates. |
| What is the difference between Regular, Best Available, and Monthly rates? | Regular returns the standard hourly or daily rate. Best Available may include discounts or special offers. Monthly returns the long-term contract rate when available. |
| How do I format the bounding box? | Use the format swLat|swLng|neLat|neLng, for example 40.70|-74.02|40.78|-73.95 for lower Manhattan. The southwest corner comes first, then the northeast corner. |
| Does the entry time affect the price? | Yes, some lots have different rates for evenings, weekends, or special events. Setting an entry time returns the rate applicable at that moment. |
| Can I get rates for multiple cities in one run? | Each run targets one city or one bounding box. To collect data for multiple cities, run the Actor once per city or use a separate orchestrator. |
| What if a lot has no rate for my chosen type? | The Actor returns the lot with a null or zero rate field. You can filter these out in your downstream processing. |
| Is there a limit on how many rates I can collect? | You set the maximum with the maxItems input, up to 1,000,000 per run. The actual number depends on how many lots exist in your search area. |
| Do I need a ParkMe account or API key? | No. The Actor reads the publicly available data from the ParkMe website, so no registration or key is required. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by ParkMe, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many parking rates to collect per run.

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

City to search parking lots, for example New York, NY. Leave empty if using Bounding Box.

## `bbox` (type: `string`):

Area in swLat|swLng|neLat|neLng format. When provided, City is ignored.

## `rateRequest` (type: `string`):

Type of rate to request.

## `duration` (type: `integer`):

Duration in minutes used for calculated rates.

## `entryTime` (type: `string`):

Optional entry time in YYYY-MM-DDTHH:MM format.

## Actor input object example

```json
{
  "maxItems": 10,
  "city": "New York, NY",
  "rateRequest": "R",
  "duration": 60,
  "entryTime": "2026-03-01T09:00"
}
```

# Actor output Schema

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

Dataset items in overview format.

# 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 = {
    "maxItems": 10,
    "city": "New York, NY",
    "rateRequest": "R",
    "duration": 60,
    "entryTime": "2026-03-01T09:00"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/parking-rate-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 = {
    "maxItems": 10,
    "city": "New York, NY",
    "rateRequest": "R",
    "duration": 60,
    "entryTime": "2026-03-01T09:00",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/parking-rate-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "city": "New York, NY",
  "rateRequest": "R",
  "duration": 60,
  "entryTime": "2026-03-01T09:00"
}' |
apify call parseforge/parking-rate-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/parking-rate-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/c8MvNmO6TZexIS6uv/builds/CNuk1IlLlTxY05Y7G/openapi.json