# US Short-Term Rental Permit & Host Leads Scraper (`scrapesage/us-short-term-rental-permit-scraper`) Actor

Scrape US short-term rental (Airbnb/VRBO) host & operator leads from official city permit registries: owner/operator name, phone, email, business entity, property address, permit status & dates, multi-property operator detection, lead score + monitoring. No browser.

- **URL**: https://apify.com/scrapesage/us-short-term-rental-permit-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.00 / 1,000 str host / operator leads

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

## US Short-Term Rental Permit & Host Leads Scraper — Airbnb & VRBO Operators (Official City Registries)

Extract **short-term rental host & operator leads** from official US city permit registries — the data Airbnb/VRBO listing scrapers can't get: **owner / operator name, phone, email, the legal business entity, the permit number, status & expiration dates, and a multi-property "professional operator" portfolio signal**. Every permitted Airbnb / VRBO property becomes a ready-to-contact B2B lead.

No login, no cookies, no browser — fast JSON extraction from government open-data portals with 99%+ reliability.

### Why this short-term rental scraper?

Airbnb/VRBO listing scrapers hide the host's real name and never expose a phone or email. This actor takes the opposite, **regulatory** angle: it reads the official short-term-rental permit / license registries that cities are legally required to publish — so you get **verified active operators with contact data and property addresses**, plus a signal no listing scraper has: which hosts run **multiple permitted properties** (property managers and professional operators — your highest-value B2B leads).

| Data | Airbnb/VRBO listing scrapers | This actor |
|---|---|---|
| Host / operator real name | ❌ first name only | ✅ full owner & operator name |
| Host **phone** | ❌ | ✅ where the city publishes it |
| Host **email** | ❌ | ✅ where the city publishes it |
| Legal business entity (LLC / Mgmt / Rentals) | ❌ | ✅ detected |
| Multi-property "professional operator" flag | ❌ | ✅ portfolio size |
| Official permit number, status & expiration | ❌ | ✅ |
| Property street address | partial | ✅ |
| Permit issue date / new-host signal | ❌ | ✅ |
| Lead score (0–100) per host | ❌ | ✅ |
| Listing platform links (Airbnb/VRBO) | n/a | ✅ where published (Cambridge) |

### Who buys these leads?

Short-term-rental hosts and operators are active, high-intent buyers — and the vendors selling to them pay for verified contact lists:

- **STR management software** (Guesty, Hostaway, Lodgify, OwnerRez–style platforms) — reach newly permitted hosts the week they register.
- **Cleaning & turnover services, dynamic pricing tools, smart-lock & supply vendors.**
- **STR-specialist insurance, lending & accounting.**
- **Co-hosting & property-management companies** prospecting owners in a new market.
- **Real estate agents & investors** targeting STR-zoned owners and absentee operators.
- Filter to **business entities** and **multi-property operators** for pure B2B portfolios.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **US Short-Term Rental Permit & Host Leads Scraper**, pick the cities (or leave all), add filters, and click **Start**.
3. Watch host & operator leads stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Coverage

Official city / county short-term-rental open-data registries (clean, keyless Socrata SoQL — no browser, no proxy):

| Source | City / county | Contact data | Notable fields |
|---|---|---|---|
| `neworleans` | New Orleans, LA (non-commercial) | **owner + operator + phone + email** | building type, bedrooms, max occupancy |
| `neworleans-comm` | New Orleans, LA (all active) | license holder name | type, geo, dates |
| `orlando` | Orlando, FL | **holder + phone + email** | status, renewal date |
| `seattle` | Seattle, WA | business-license number | property type, bedrooms |
| `denver` | Denver, CO | — | license type, parcel, expiration |
| `cambridge` | Cambridge, MA | — | Airbnb/VRBO listing links, bedrooms, occupancy |
| `marin` | Marin County, CA | business name | parcel, registration date |
| `norfolk` | Norfolk, VA | — | bedrooms, max guests, type |
| `austin` | Austin, TX | — | STR type, property address |

More cities are added over time — the source list grows without changing your inputs.

### Input

```json
{
    "sources": ["neworleans", "orlando", "marin"],
    "withContactOnly": true,
    "businessEntitiesOnly": false,
    "multiPropertyOnly": false,
    "activeOnly": true,
    "newPermitsOnly": false,
    "sortBy": "leadScore",
    "maxResults": 500
}
````

- **sources** — which city registries to query (leave empty for all). **states** — narrow to 2-letter state codes.
- **nameQuery / cities / zipCodes** — search & location filters.
- **withContactOnly / withEmailOnly / withPhoneOnly** — keep only permits with reachable contact data.
- **businessEntitiesOnly** — only LLC / Inc / Properties / Management / Rentals operators (B2B).
- **multiPropertyOnly** — only hosts holding **2+ permits** in the scanned data (property managers / professional operators).
- **strScope** — `owner-occupied` vs `whole-unit` (whole-unit = dedicated investment property).
- **statuses / activeOnly** — filter by permit status.
- **minBedrooms / minOccupancy** — size filters (larger property = bigger operator).
- **newPermitsOnly / newPermitDays** — brand-new hosts only (top GTM intent).
- **issuedAfter / expiringBefore** — freshness & renewal-timing windows.
- **minLeadScore / sortBy / maxResults / maxResultsPerSource** — quality, ordering & limits.
- **monitorMode / monitorKey** — return only permits that are new since the last run.

### Output

One record per permitted STR property (`recordType: "str_permit"`):

```json
{
    "recordType": "str_permit",
    "source": "neworleans",
    "city": "New Orleans",
    "state": "LA",
    "permitId": "STRNC-2026-01234",
    "permitType": "license",
    "status": "active",
    "isActive": true,
    "strType": "owner-occupied / partial",
    "contactName": "Crescent City Stays LLC",
    "ownerName": "Jane Doe",
    "operatorName": "Crescent City Stays LLC",
    "entityType": "business",
    "isBusinessEntity": true,
    "phone": "(504) 555-0142",
    "email": "host@crescentcitystays.com",
    "hasContact": true,
    "propertyAddress": "1234 Magazine St, New Orleans, LA",
    "latitude": 29.9298,
    "longitude": -90.0855,
    "propertyType": "Single-Family",
    "bedrooms": 3,
    "maxOccupancy": 8,
    "listingPlatforms": ["Airbnb"],
    "applicationDate": "2026-01-15",
    "expirationDate": "2027-01-15",
    "isNewPermit": true,
    "portfolioSize": 6,
    "isMultiProperty": true,
    "isProfessionalOperator": true,
    "operatorOtherCities": null,
    "leadScore": 92,
    "leadSignals": ["email", "phone", "business_entity", "professional_operator", "new_permit"],
    "sourceFields": { "...": "every original column, nothing dropped" },
    "scrapedAt": "2026-06-20T12:00:00.000Z"
}
```

Every original column from the source registry is preserved under `sourceFields`, so you never lose data.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to capture newly permitted hosts as fresh leads.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/us-short-term-rental-permit-scraper').call({
    sources: ['neworleans', 'orlando', 'marin'],
    withContactOnly: true,
    activeOnly: true,
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} STR host & operator leads`);
```

### Monitoring — only new hosts

Turn on **monitorMode** and the actor remembers which permits it already returned (in a named key-value store) and emits **only new / renewed / changed permits** on the next run, each tagged `monitorEvent: "new"`. Pair it with a [Schedule](https://docs.apify.com/platform/schedules) to build a continuous feed of newly permitted Airbnb/VRBO hosts. Monitoring is **orthogonal to Apify Schedules** — the schedule starts the run; monitoring decides what counts as new — so the two never conflict. Use a distinct `monitorKey` per saved watch.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new host leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored city registers new STR permits.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find newly permitted whole-unit Airbnb operators in New Orleans with an email" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **real-estate & short-term-rental lead-gen stack**:

- **[Airbnb Scraper & Market Monitor](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices, occupancy & availability for the same markets.
- **[Booking.com Scraper](https://apify.com/scrapesage/booking-scraper)** — hotels, prices & availability.
- **[Rent.com Scraper](https://apify.com/scrapesage/rent-com-scraper)** — apartments, rentals & property leads.
- **[Redfin Scraper](https://apify.com/scrapesage/redfin-scraper)** — listings, sold comps, estimates & owner leads.
- **[Crexi Scraper](https://apify.com/scrapesage/crexi-scraper)** — commercial real estate, prices & broker leads.
- **[US Business Formation Scraper](https://apify.com/scrapesage/us-business-formation-scraper)** — new LLC & company leads (catch operators the moment they register an entity).
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — enrich a host's website with emails, phones & socials.

### Tips

- **Best contact coverage**: `neworleans` (non-commercial) and `orlando` publish phone & email. Combine with `withContactOnly` for outreach-ready lists.
- **Pure B2B**: turn on `businessEntitiesOnly` and/or `multiPropertyOnly`, sort by `portfolioSize`, to surface property managers and professional operators first.
- **GTM intent**: `newPermitsOnly` + a daily `monitorMode` schedule = a live feed of hosts the week they get licensed.
- **Cost control**: tighten filters and `maxResults`; the actor only charges for delivered lead records.

### FAQ

**Where does the data come from?** Official city / county short-term-rental permit registries published as open data (Socrata). It's the same public record a resident can search — structured, deduplicated, scored and combined across cities.

**Which cities have phone & email?** New Orleans (non-commercial) publishes owner + operator + phone + email; Orlando publishes holder + phone + email. Other cities publish names, business entities and/or property details — fields are `null` only when a city doesn't publish them.

**What is the "professional operator" signal?** The actor groups every scanned permit by host/operator identity (email, phone, then name). A host holding 2+ permits is flagged `isMultiProperty`; 3+ (or any business entity) is flagged `isProfessionalOperator` with a `portfolioSize` count — exactly the property-manager leads STR vendors want.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I get only new hosts?** Turn on `monitorMode` and run on a [Schedule](https://docs.apify.com/platform/schedules); only permits new since the last run are returned.

**Is scraping this data legal?** This actor collects publicly available government records only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and each portal's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests — especially new cities — are welcome; this actor is actively maintained.

# Actor input Schema

## `sources` (type: `array`):

Which official city / county short-term-rental permit registries to query. <b>neworleans</b> = New Orleans non-commercial STRs (owner + operator + phone + email). <b>neworleans-comm</b> = New Orleans all active STR licenses (license holder + geo). <b>orlando</b> = Orlando, FL (holder + phone + email). <b>seattle</b> = Seattle, WA (business-license linked). <b>denver</b> = Denver, CO. <b>cambridge</b> = Cambridge, MA (property + Airbnb/VRBO listing links). <b>marin</b> = Marin County, CA (business name). <b>norfolk</b> = Norfolk, VA (bedrooms + max guests). <b>austin</b> = Austin, TX. Leave empty for all.

## `states` (type: `array`):

Optionally restrict to these 2-letter state codes (<code>LA</code>, <code>FL</code>, <code>WA</code>, <code>CO</code>, <code>MA</code>, <code>CA</code>, <code>VA</code>, <code>TX</code>). Narrows the selected sources to those states.

## `nameQuery` (type: `string`):

Only return permits whose owner / operator / business name contains this text (case-insensitive), e.g. <code>Vacasa</code>, <code>Properties</code>, or a surname. Applied server-side where the source publishes a name field, otherwise client-side.

## `cities` (type: `array`):

Filter by the property's city / town (case-insensitive exact match). Useful inside county sources — e.g. <code>San Rafael</code>, <code>Mill Valley</code>, <code>Sausalito</code> (Marin County). Single-city sources ignore this.

## `zipCodes` (type: `array`):

Filter by property ZIP — full ZIP (<code>32801</code>) or a prefix (<code>328</code> matches all 328xx).

## `leadFilters` (type: `string`):

The filters below target the best STR host / operator leads.

## `withContactOnly` (type: `boolean`):

Only permits that have a phone number OR an email address. Best for direct outreach lists. (Contact data is published by New Orleans non-commercial and Orlando.)

## `withEmailOnly` (type: `boolean`):

Only permits with an email address — the highest-converting STR host leads.

## `withPhoneOnly` (type: `boolean`):

Only permits with a phone number — best for tele-prospecting.

## `businessEntitiesOnly` (type: `boolean`):

Only permits held by a business entity (LLC, Inc, Properties, Management, Rentals, etc.) or flagged commercial — professional STR operators, the highest-value B2B leads.

## `multiPropertyOnly` (type: `boolean`):

Only hosts / operators that hold 2+ permits in the scanned data — property managers and professional operators running portfolios. Premium B2B leads for STR software, co-hosting, cleaning & insurance vendors.

## `strScope` (type: `array`):

Filter by normalized rental scope. <b>owner-occupied</b> = owner-occupied / partial / homestay / private room. <b>whole-unit</b> = whole-unit / non-owner-occupied / commercial (typically a dedicated investment property = stronger B2B lead).

## `statuses` (type: `array`):

Filter by normalized permit status. <b>active</b> = active / current / issued / valid. <b>pending</b> = application in review. <b>expired</b> = past expiration. <b>inactive</b> = closed / revoked / cancelled / surrendered. <b>unknown</b> = status not published. Leave empty for all.

## `activeOnly` (type: `boolean`):

Shortcut for status = active and not past expiration. Recommended for live outreach lists.

## `minBedrooms` (type: `integer`):

Only properties with at least this many bedrooms (where published — Seattle, Cambridge, Norfolk).

## `minOccupancy` (type: `integer`):

Only properties licensed for at least this many guests (where published — New Orleans, Cambridge, Norfolk). Larger properties = bigger operators.

## `newPermitsOnly` (type: `boolean`):

Only permits issued within the new-permit window below. Brand-new STR hosts are the highest-intent buyers — they need management software, cleaning, dynamic pricing, insurance, furnishing & supplies.

## `newPermitDays` (type: `integer`):

How recent the permit issue / application date must be to count as 'newly permitted'. Default 365.

## `issuedAfter` (type: `string`):

Only permits issued / applied on or after this date (YYYY-MM-DD).

## `expiringBefore` (type: `string`):

Only permits expiring on or before this date (YYYY-MM-DD) — renewal-timing leads (where the source publishes an expiration date).

## `minLeadScore` (type: `integer`):

Only return records with a lead score (0–100) at or above this value.

## `includeSourceFields` (type: `boolean`):

Attach the full original permit row (every published column) as <code>sourceFields</code> on each record, so no data is lost. Turn off for a leaner dataset.

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

Maximum number of host / operator lead records to return in this run (across all selected cities).

## `maxResultsPerSource` (type: `integer`):

Cap how many records are taken from each city before the global limit and sorting. Leave blank to use the same value as Max results.

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

Order of the returned records. <b>leadScore</b> = best leads first (default). <b>newest</b> = most recently issued permits first. <b>portfolioSize</b> = biggest multi-property operators first. <b>occupancy</b> = largest properties first. <b>none</b> = natural order (fastest).

## `deduplicateResults` (type: `boolean`):

Skip duplicate permit records within this run (recommended).

## `monitorMode` (type: `boolean`):

Remember which permits were already returned (in a named key-value store) and emit ONLY records that are new since the last run — each tagged <code>monitorEvent: "new"</code>. A renewal, a status change or a brand-new permit also surfaces as new. Run on a Schedule to capture new STR hosts as fresh leads. Works alongside Apify Schedules (the schedule starts the run; monitoring decides what's new).

## `monitorKey` (type: `string`):

Names the memory used by monitoring mode. Use a distinct key per saved watch (e.g. per city or filter) so different monitors don't share state.

## `socrataAppToken` (type: `string`):

Optional Socrata app token for higher rate limits on very large runs. Not required — leave blank for normal use. Get one free at any of the open-data portals (e.g. data.nola.gov).

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

Optional proxy. The government open-data portals are fetched directly and need no proxy — leave this off for the fastest runs. Enable Apify Proxy only if your network requires it.

## Actor input object example

```json
{
  "sources": [
    "neworleans",
    "neworleans-comm",
    "orlando",
    "seattle",
    "denver",
    "cambridge",
    "marin",
    "norfolk",
    "austin"
  ],
  "withContactOnly": false,
  "withEmailOnly": false,
  "withPhoneOnly": false,
  "businessEntitiesOnly": false,
  "multiPropertyOnly": false,
  "activeOnly": false,
  "newPermitsOnly": false,
  "newPermitDays": 365,
  "includeSourceFields": true,
  "maxResults": 1000,
  "sortBy": "leadScore",
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped short-term-rental permit / host lead records as JSON items in the default dataset.

# 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 = {
    "sources": [
        "neworleans",
        "neworleans-comm",
        "orlando",
        "seattle",
        "denver",
        "cambridge",
        "marin",
        "norfolk",
        "austin"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/us-short-term-rental-permit-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 = {
    "sources": [
        "neworleans",
        "neworleans-comm",
        "orlando",
        "seattle",
        "denver",
        "cambridge",
        "marin",
        "norfolk",
        "austin",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/us-short-term-rental-permit-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 '{
  "sources": [
    "neworleans",
    "neworleans-comm",
    "orlando",
    "seattle",
    "denver",
    "cambridge",
    "marin",
    "norfolk",
    "austin"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapesage/us-short-term-rental-permit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/us-short-term-rental-permit-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Short-Term Rental Permit & Host Leads Scraper",
        "description": "Scrape US short-term rental (Airbnb/VRBO) host & operator leads from official city permit registries: owner/operator name, phone, email, business entity, property address, permit status & dates, multi-property operator detection, lead score + monitoring. No browser.",
        "version": "0.1",
        "x-build-id": "whmfvzW2xKdsfKyFn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~us-short-term-rental-permit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-us-short-term-rental-permit-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/scrapesage~us-short-term-rental-permit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-us-short-term-rental-permit-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/scrapesage~us-short-term-rental-permit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-us-short-term-rental-permit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sources": {
                        "title": "Cities / data sources",
                        "type": "array",
                        "description": "Which official city / county short-term-rental permit registries to query. <b>neworleans</b> = New Orleans non-commercial STRs (owner + operator + phone + email). <b>neworleans-comm</b> = New Orleans all active STR licenses (license holder + geo). <b>orlando</b> = Orlando, FL (holder + phone + email). <b>seattle</b> = Seattle, WA (business-license linked). <b>denver</b> = Denver, CO. <b>cambridge</b> = Cambridge, MA (property + Airbnb/VRBO listing links). <b>marin</b> = Marin County, CA (business name). <b>norfolk</b> = Norfolk, VA (bedrooms + max guests). <b>austin</b> = Austin, TX. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "neworleans",
                                "neworleans-comm",
                                "orlando",
                                "seattle",
                                "denver",
                                "cambridge",
                                "marin",
                                "norfolk",
                                "austin"
                            ],
                            "enumTitles": [
                                "New Orleans, LA — Non-Commercial (owner+operator+email)",
                                "New Orleans, LA — All Active",
                                "Orlando, FL (phone+email)",
                                "Seattle, WA",
                                "Denver, CO",
                                "Cambridge, MA (listing links)",
                                "Marin County, CA",
                                "Norfolk, VA",
                                "Austin, TX"
                            ]
                        },
                        "default": [
                            "neworleans",
                            "neworleans-comm",
                            "orlando",
                            "seattle",
                            "denver",
                            "cambridge",
                            "marin",
                            "norfolk",
                            "austin"
                        ]
                    },
                    "states": {
                        "title": "States (optional)",
                        "type": "array",
                        "description": "Optionally restrict to these 2-letter state codes (<code>LA</code>, <code>FL</code>, <code>WA</code>, <code>CO</code>, <code>MA</code>, <code>CA</code>, <code>VA</code>, <code>TX</code>). Narrows the selected sources to those states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nameQuery": {
                        "title": "Owner / operator name contains",
                        "type": "string",
                        "description": "Only return permits whose owner / operator / business name contains this text (case-insensitive), e.g. <code>Vacasa</code>, <code>Properties</code>, or a surname. Applied server-side where the source publishes a name field, otherwise client-side."
                    },
                    "cities": {
                        "title": "Cities / towns",
                        "type": "array",
                        "description": "Filter by the property's city / town (case-insensitive exact match). Useful inside county sources — e.g. <code>San Rafael</code>, <code>Mill Valley</code>, <code>Sausalito</code> (Marin County). Single-city sources ignore this.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes (prefix)",
                        "type": "array",
                        "description": "Filter by property ZIP — full ZIP (<code>32801</code>) or a prefix (<code>328</code> matches all 328xx).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "leadFilters": {
                        "title": "Lead & host filters",
                        "type": "string",
                        "description": "The filters below target the best STR host / operator leads."
                    },
                    "withContactOnly": {
                        "title": "With phone or email only",
                        "type": "boolean",
                        "description": "Only permits that have a phone number OR an email address. Best for direct outreach lists. (Contact data is published by New Orleans non-commercial and Orlando.)",
                        "default": false
                    },
                    "withEmailOnly": {
                        "title": "With email only",
                        "type": "boolean",
                        "description": "Only permits with an email address — the highest-converting STR host leads.",
                        "default": false
                    },
                    "withPhoneOnly": {
                        "title": "With phone only",
                        "type": "boolean",
                        "description": "Only permits with a phone number — best for tele-prospecting.",
                        "default": false
                    },
                    "businessEntitiesOnly": {
                        "title": "Business operators only (B2B)",
                        "type": "boolean",
                        "description": "Only permits held by a business entity (LLC, Inc, Properties, Management, Rentals, etc.) or flagged commercial — professional STR operators, the highest-value B2B leads.",
                        "default": false
                    },
                    "multiPropertyOnly": {
                        "title": "Multi-property operators only",
                        "type": "boolean",
                        "description": "Only hosts / operators that hold 2+ permits in the scanned data — property managers and professional operators running portfolios. Premium B2B leads for STR software, co-hosting, cleaning & insurance vendors.",
                        "default": false
                    },
                    "strScope": {
                        "title": "Rental scope",
                        "type": "array",
                        "description": "Filter by normalized rental scope. <b>owner-occupied</b> = owner-occupied / partial / homestay / private room. <b>whole-unit</b> = whole-unit / non-owner-occupied / commercial (typically a dedicated investment property = stronger B2B lead).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "owner-occupied",
                                "whole-unit"
                            ],
                            "enumTitles": [
                                "Owner-occupied / partial / homestay",
                                "Whole-unit / non-owner-occupied"
                            ]
                        }
                    },
                    "statuses": {
                        "title": "Permit status",
                        "type": "array",
                        "description": "Filter by normalized permit status. <b>active</b> = active / current / issued / valid. <b>pending</b> = application in review. <b>expired</b> = past expiration. <b>inactive</b> = closed / revoked / cancelled / surrendered. <b>unknown</b> = status not published. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "active",
                                "pending",
                                "expired",
                                "inactive",
                                "unknown"
                            ],
                            "enumTitles": [
                                "Active",
                                "Pending",
                                "Expired",
                                "Inactive / closed",
                                "Unknown"
                            ]
                        }
                    },
                    "activeOnly": {
                        "title": "Active permits only",
                        "type": "boolean",
                        "description": "Shortcut for status = active and not past expiration. Recommended for live outreach lists.",
                        "default": false
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only properties with at least this many bedrooms (where published — Seattle, Cambridge, Norfolk)."
                    },
                    "minOccupancy": {
                        "title": "Min max-occupancy / guests",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only properties licensed for at least this many guests (where published — New Orleans, Cambridge, Norfolk). Larger properties = bigger operators."
                    },
                    "newPermitsOnly": {
                        "title": "Newly permitted only (GTM intent)",
                        "type": "boolean",
                        "description": "Only permits issued within the new-permit window below. Brand-new STR hosts are the highest-intent buyers — they need management software, cleaning, dynamic pricing, insurance, furnishing & supplies.",
                        "default": false
                    },
                    "newPermitDays": {
                        "title": "New-permit window (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How recent the permit issue / application date must be to count as 'newly permitted'. Default 365.",
                        "default": 365
                    },
                    "issuedAfter": {
                        "title": "Issued on/after",
                        "type": "string",
                        "description": "Only permits issued / applied on or after this date (YYYY-MM-DD)."
                    },
                    "expiringBefore": {
                        "title": "Expiring on/before",
                        "type": "string",
                        "description": "Only permits expiring on or before this date (YYYY-MM-DD) — renewal-timing leads (where the source publishes an expiration date)."
                    },
                    "minLeadScore": {
                        "title": "Minimum lead score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return records with a lead score (0–100) at or above this value."
                    },
                    "includeSourceFields": {
                        "title": "Include raw source fields",
                        "type": "boolean",
                        "description": "Attach the full original permit row (every published column) as <code>sourceFields</code> on each record, so no data is lost. Turn off for a leaner dataset.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of host / operator lead records to return in this run (across all selected cities).",
                        "default": 1000
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source (optional)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap how many records are taken from each city before the global limit and sorting. Leave blank to use the same value as Max results."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "leadScore",
                            "newest",
                            "portfolioSize",
                            "occupancy",
                            "none"
                        ],
                        "type": "string",
                        "description": "Order of the returned records. <b>leadScore</b> = best leads first (default). <b>newest</b> = most recently issued permits first. <b>portfolioSize</b> = biggest multi-property operators first. <b>occupancy</b> = largest properties first. <b>none</b> = natural order (fastest).",
                        "default": "leadScore"
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate within a run",
                        "type": "boolean",
                        "description": "Skip duplicate permit records within this run (recommended).",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new records",
                        "type": "boolean",
                        "description": "Remember which permits were already returned (in a named key-value store) and emit ONLY records that are new since the last run — each tagged <code>monitorEvent: \"new\"</code>. A renewal, a status change or a brand-new permit also surfaces as new. Run on a Schedule to capture new STR hosts as fresh leads. Works alongside Apify Schedules (the schedule starts the run; monitoring decides what's new).",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Names the memory used by monitoring mode. Use a distinct key per saved watch (e.g. per city or filter) so different monitors don't share state.",
                        "default": "default"
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional Socrata app token for higher rate limits on very large runs. Not required — leave blank for normal use. Get one free at any of the open-data portals (e.g. data.nola.gov)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The government open-data portals are fetched directly and need no proxy — leave this off for the fastest runs. Enable Apify Proxy only if your network requires it.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
