# Airbnb US Registration Number Checker (`nice_dev/airbnb-us-license-checker`) Actor

Check the short-term rental registration number of Airbnb listings in the US against official public registers (Hawaii, Los Angeles, San Diego, Chicago, Denver, Seattle, Philadelphia, Austin, Cambridge): verdict, registered holder's full name, exact address, property owner, status and expiry.

- **URL**: https://apify.com/nice_dev/airbnb-us-license-checker.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Travel, Real estate, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.59 / 1,000 airbnb listing checkeds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### 🏠 What is Airbnb US Registration Number Checker?

**Airbnb US Registration Number Checker** checks the **short-term rental registration or licence number** that each Airbnb listing in the United States displays against the **official public register of its city or county** — Hawaii (the state's tax licences on every island, and Honolulu's property roll), Los Angeles, San Diego, Chicago, Denver, Seattle, Philadelphia, Austin and Cambridge (MA) — and tells you whether it is **valid, expired, not in the register, used for another property, or closed for tax**. Each result gives what the register knows and Airbnb hides: the **registered holder's full name**, the **exact address with the unit number**, the **property owner(s)** with the tax bill mailing address and the assessed value (option **Property owner**), the phone of the local contact where the city publishes it, the status and the expiry date — plus the listing's own details (host, capacity, rating, amenities, price).

Type a **place** (`Honolulu, HI`), draw a **map area**, paste **Airbnb URLs** or **listing IDs**, give **registration numbers** alone — or ask for **whole city registers** — click **Start**, and download the results in JSON, CSV or Excel. No login, nothing to set up. Built for city and county enforcement teams, tax auditors, property managers, HOAs, investors, insurers and journalists.

### 📋 What data can you extract from Airbnb and the US short-term rental registers?

One item per listing checked (or per registration number, or per register record), 150 fields:

| Category | What you get |
| --- | --- |
| ✅ **Verdict** | valid, not in the register, expired, tax location closed, another property's number, over capacity, exempt claimed… with the reasons and one plain sentence |
| 🪪 **Registration numbers** | the number shown on the listing and how the register writes it, its kind (home-sharing, tax licence, operator licence…), the parcel (Hawaii TMK), the other numbers shown, the other listings of the run showing the same number |
| 🏛️ **Official register** | registered holder's full name, person or company, holder's address, phone and local contact (San Diego, Seattle), owner or tenant, status, issue and expiry dates, registration history, tax accounts, exact address with unit and building, ZIP code, district, bedrooms and guests allowed, position and distance to the listing |
| 🏡 **Property roll** (option **Property owner**) | owner(s) of the property, where the tax bill is sent, legal description, assessed value, last sale (Denver), whether the holder is an owner; Philadelphia's owner of record comes with its register |
| 🏠 **Listing** | title, type of place, city, position, guests, bedrooms, beds, bathrooms, rating and sub-ratings, badges, highlights, house rules, where you'll sleep, description, amenities, photos |
| 👤 **Host** | name, profile link, business or individual, verified, years hosting, response rate and time, rating, reviews, co-hosts, how many listings they manage |
| 📅 **Availability calendar** (option **Availability calendar**) | nights open and nights booked or blocked over the next 12 months, per month and per day, minimum stay; in Los Angeles, whether the listing is open to short stays past the 120 days a year Home-Sharing allows |
| 🎯 **Risk score** (option **Risk score (0-100)**) | a score from 0 to 100 per listing and the short codes of the rules behind it: the verdict, a number shown twice, a registered address far from the listing, a host with several listings, a calendar open past the night cap of the city… |
| 🏢 **Professional host contact** (option) | business email and phone of professional Airbnb hosts, from publicly available sources |
| 📷 **Photos** (option **Download photos**) | the first photos of each listing kept in the run's storage, with their public links, their SHA-256 and the time of the download — the links to the photos on Airbnb stay free |
| ⚡ **Cards only** (option **Cards only (fast)**) | the card of each Airbnb search result — link, title, type, price, rating, position, bedrooms — without opening the listing, so without a number or a verdict |
| 🏘️ **Comparables** (option **Comparable listings**) | the nearest Airbnb listings of the same type and size around each Airbnb listing, with their price per night, rating and distance, and their median price |
| 💰 **Revenue estimate** (option **Revenue estimate (12 months)**) | an estimate of the nights blocked in the calendar, the revenue they would make at the price per night searched, and the share of the calendar blocked |
| 🏷️ **AI labels** (option **AI labels**) | five yes / no labels read in the description of an Airbnb listing — managed by a company, self check-in, monthly stays, host not living there, licence mentioned — with their scores |
| 💵 **Price** | total price of the stay, price per night, price breakdown, dates (from the search results) |

Every field, with an example, is listed in the **Output** section below.

### ✅ Why use Airbnb US Registration Number Checker?

- 🏛️ **The official registers, not a format check**: each number is looked up live in the public register of its city or county, at the time of the run.
- 🔎 **What Airbnb hides, from the listing itself**: the registered holder's full name and the exact address with the unit — no need to know the address first (Honolulu: the building and unit come from the property roll, option **Property owner**).
- 🏡 **Who owns the place** (option **Property owner**): the property roll behind the licence (Honolulu from the parcel the listing shows, Denver from the licence), and whether the holder is an owner.
- 📅 **The 120-day cap of Los Angeles** (option **Availability calendar**): each listing's calendar for the next 12 months, and whether it is open to short stays on more than the 120 days a calendar year a Regular Home-Sharing registration allows (the register tells Regular from Extended).
- 🌴 **All of Hawaii**: the state's tax licence is checked on Oahu, Maui, Kauai and the Big Island, with the status of the rental location.
- 🗂️ **Seven ways in, in one run**: places, map areas, search URLs, listing URLs, listing IDs, registration numbers alone, whole city registers.
- 🗺️ **Whole cities**: Airbnb shows 270 listings per search; a full area is cut into smaller ones automatically to reach the others.
- 🔔 **Monitoring built in**: tick **Only new listings**, schedule the Actor, and each run returns (and charges) only what it has never delivered before.
- 🔌 API, scheduling, integrations (Make, Zapier, n8n, Google Sheets…) and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to check Airbnb registration numbers in the US

1. Create a free Apify account.
2. Open **Airbnb US Registration Number Checker** and type a **Place** (e.g. `Honolulu, HI`).
3. Or paste **Airbnb URLs** (search results or single listings), **listing IDs**, **map areas**, **registration numbers** without any listing, or pick **whole city registers**.
4. Set **Max results** (100 by default, 0 = no limit) — and keep only the suspicious listings with **Keep only these verdicts** — then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to check Airbnb registration numbers?

This Actor uses **pay per event** pricing: a price per Airbnb listing checked, a price per registration number or register record checked without any listing, a price per **card alone** (`listing-card`, the only price of a run with **Cards only (fast)**), a small fee per run start, a fee per result that comes with the county **property roll** (**Property owner**, off by default: owners, tax bill address, value, last sale — Honolulu and Denver; a result the roll gives nothing for costs nothing extra), a fee per **host profile** (**Host's listing count**, off by default, one per host whose profile reaches your results, not per listing), a fee per listing whose **availability calendar** reaches your results (**Availability calendar**, off by default), a fee per listing whose **risk score** reaches your results (**Risk score (0-100)**, off by default, no extra request), a fee per **professional host contact** (`pro-host-contact`, **Professional host contact**, off by default, one per Airbnb listing whose row carries an e-mail or a phone of the host's company), a fee per **photo downloaded** (**Download photos**, off by default, the links to the photos stay free), a fee per listing given its **comparables** (**Comparable listings**, off by default, no listing page opened), a fee per listing given its **revenue estimate** (**Revenue estimate (12 months)**, off by default, needs dates and reads the calendar too), a fee per listing given its **AI labels** (**AI labels**, off by default, needs 2 GB of memory) and a lower fee for each result a filter of the Actor drops — `filter-check` when the search results are enough to drop a listing (minimum rating, host type, excluded words), `detail-filter-check` when its page and register had to be read (verdicts, places, holder type, phone; also a number or a register record these filters drop). A result you keep costs its normal price: filtering never costs more than taking everything. The prices are shown on the **Pricing** tab of this page. Platform usage (compute, proxy) is included in the price.

### ⚙️ Input

A place, only the listings whose number does not match the register:

```json
{
    "location": "Honolulu, HI",
    "maxItems": 200,
    "onlyVerdicts": ["not_in_register", "expired", "location_closed", "other_property"]
}
```

Several places and a map area, a cap per search, only the listings not delivered before:

```json
{
    "locations": ["Los Angeles, CA", "San Diego, CA"],
    "boundingBoxes": ["21.26, -157.84, 21.29, -157.81"],
    "maxItemsPerQuery": 100,
    "onlyNew": true,
    "stateKey": "west-coast"
}
```

Your own URLs, listing IDs, and registration numbers alone:

```json
{
    "startUrls": [
        { "url": "https://www.airbnb.com/s/Chicago--IL/homes?adults=2" },
        { "url": "https://www.airbnb.com/rooms/659011938895363888" }
    ],
    "listingIds": ["50663470"],
    "licenseNumbers": ["HSR25-000906", "R26000144381", "TA-201-566-9248-02", "STR-13904L"],
    "maxItems": 500
}
```

Whole city registers, the registrations of this year, without any Airbnb search:

```json
{
    "registerLists": ["chicago", "denver"],
    "registeredAfter": "2026-01-01",
    "maxItemsPerQuery": 1000
}
```

| Field | Notes |
| --- | --- |
| `startUrls` | Airbnb search results pages (filters kept, pagination and map splitting automatic) or single listing pages, any Airbnb domain. |
| `listingIds` | Airbnb listing IDs alone (the digits after `/rooms/`). Checked in the order given and before any search: with `maxItems`, the first ones are the ones saved. |
| `location`, `locations` | Places as typed in Airbnb's search box (e.g. `Honolulu, HI`, `Los Angeles, CA`); one search each. |
| `boundingBoxes` | Map rectangles `south, west, north, east` (e.g. `21.26, -157.84, 21.29, -157.81`): the surest way to cover a whole city. |
| `licenseNumbers` | Registration numbers checked in their register without any listing (e.g. `HSR25-000906`, `R26000144381`, `TA-201-566-9248-02`, `2025-BFN-0011695`, `STR-13904L`). The register is picked from the number's format; a bare 7 digits may be Chicago's or Philadelphia's: prefix the city (`Chicago: 3056909`) or both are checked. One result per number; several numbers in one entry (commas, semicolons or line breaks between them) count one each. |
| `registerLists` | Whole city registers, without any Airbnb search: `chicago`, `denver`, `seattle`, `san_diego`, `philadelphia`, `austin`, `cambridge`, `los_angeles`. |
| `maxItems` | Stop after this many results for the whole run (`0` = unlimited). |
| `maxItemsPerQuery` | Cap for EACH search (place, map area or search URL) and each whole register. 0 = no cap. |
| `splitMap` | Cut a full search (270 listings) into smaller map areas to reach the others (default on). |
| `checkIn`, `checkOut`, `adults`, `children`, `infants`, `pets` | Travel dates and guests sent to Airbnb's search (e.g. `2027-07-12`, today or later in Hawaii); the price of the stay then follows them. |
| `currency`, `priceMin`, `priceMax` | Currency of the prices (`USD`, `EUR`, `GBP`, `CAD`) and price per night bounds. |
| `roomTypes` | Airbnb's type of place: `entire_home`, `private_room`, `shared_room`, `hotel_room`. |
| `propertyTypes` | Airbnb's property type: `house`, `apartment`, `guesthouse`, `hotel`. |
| `minBedrooms`, `minBeds`, `minBathrooms`, `superhostOnly` | Airbnb's own filters: at least this many rooms, Superhosts only. |
| `registeredAfter`, `activeOnly` | Whole registers only: registrations issued on or after a date (e.g. `2026-01-01`, or `30 days`; Los Angeles: the first registration, not a renewal; Chicago: the year in the number and the last status change; Seattle, San Diego and Austin give no date and list everything), active ones only (default on). |
| `onlyVerdicts` | Keep only the results with these verdicts (e.g. `not_in_register`, `expired`, `over_capacity`). |
| `jurisdictions` | Keep only the results of these places (`honolulu`, `maui`, `kauai`, `hawaii_county`, `los_angeles`, `san_diego`, `chicago`, `denver`, `seattle`, `philadelphia`, `austin`, `cambridge`, `other`). |
| `holderType` | `any`, `person` or `company` as the registered holder. |
| `onlyWithPhone` | Only results with a phone from the register (San Diego, Seattle). |
| `hostType` | `any`, `business` or `individual` hosts, as Airbnb labels them. |
| `minRating`, `excludeKeywords` | Minimum rating out of 5; words that drop a listing whose title contains them. |
| `gpsToleranceKm` | Distance above which a registered property is another one (`1.5` km by default: Airbnb blurs positions). |
| `includeOwner` | Add the property owner(s) from the county property roll (Honolulu, Denver; default off, charged per result that comes with the roll). |
| `includeHostProfile` | Read each host's profile once for the number of listings they manage (default off, charged per host whose profile reaches your results). |
| `includeCalendar` | Read each listing's availability calendar for the next 12 months (1 extra request per listing; default off, charged per listing whose calendar reaches your results). |
| `includeRiskScore` | Give each listing a risk score from 0 to 100 and its reasons (default off, charged per listing whose row carries a score). |
| `includeProHostContact` | Add the business e-mail and phone of professional Airbnb hosts, from publicly available sources (default off: charged per listing given a contact; never a private person). |
| `downloadPhotos`, `maxPhotosPerListing` | Download the first photos of each listing into the run's key-value store, with their links, SHA-256 and time (default off, charged per photo delivered; the second field is the most kept per listing, 5 by default). |
| `cardsOnly` | Deliver only the card of each Airbnb search result and open no listing (default off: no number, no verdict; a price per card, nothing else charged). |
| `includeComparables`, `maxComparablesPerListing` | Add the neighbouring Airbnb listings of each Airbnb listing and their median price per night (default off, charged per listing given comparables; the second field is the most kept per listing, 10 by default). |
| `includeRevenueEstimate` | Estimate each Airbnb listing's revenue from its calendar and its price per night (default off: needs `checkIn` and `checkOut`, reads the calendar too; charged per listing given an estimate). |
| `includeAiLabels` | Label the description of each Airbnb listing with five AI labels (default off, charged per listing given its labels; needs 2 GB of memory, otherwise skipped and not charged). |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the results never delivered under this memory key; `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

A real result, with the option **Property owner** ticked (the `owner…`, `property…`, `registerUnit` and `registerBuilding` fields of Honolulu come from it; shortened: some fields and list entries left out; the names of private persons changed):

```json
{
    "id": "50663470",
    "source": "airbnb_listing",
    "url": "https://www.airbnb.com/rooms/50663470",
    "title": "Royal Aloha Waikiki 2 bedroom WiFi Kitchen 809",
    "verdict": "valid",
    "verdictReasons": [],
    "verdictNote": "TA-201-566-9248-02 is registered (Open).",
    "isSuspicious": false,
    "jurisdiction": "honolulu",
    "state": "HI",
    "registrationText": "260140260070, TA-201-566-9248-02",
    "licenseNumber": "TA-201-566-9248-02",
    "licenseNumberNormalized": "TA-201-566-9248-02",
    "licenseType": "transient_accommodations_tax",
    "otherLicenseNumbers": [
        {
            "number": "260140260070",
            "kind": "tmk"
        }
    ],
    "parcelNumber": "260140260070",
    "numberSharedWith": [],
    "registerFound": true,
    "registerNumber": "TA-201-566-9248-02",
    "registerType": "Transient Accommodations",
    "registerStatus": "Open",
    "registerIssuedDate": "2017-06-01",
    "registerHolder": "KAI M. NAKAMURA",
    "registerHolderType": "person",
    "registerUnit": "809",
    "registerBuilding": "ROYAL ALOHA",
    "registerTaxNumber": "TA-201-566-9248-02",
    "registerOtherAccounts": [
        {
            "account": "GE-201-566-9248-01",
            "type": "General Excise / Use",
            "start": "2019-01-01",
            "end": null,
            "accountStatus": "Open",
            "locationStatus": "Open"
        }
    ],
    "registerLocationStatus": "Open",
    "ownerNames": [
        "ALOHA SECURITIES & INV CO",
        "NAKAMURA,KAI M",
        "LEE,ANNA"
    ],
    "ownerMailingAddress": "841 BISHOP STREET 940, HONOLULU HI 96813",
    "holderIsOwner": true,
    "propertyLegalDescription": "APT 809 ROYAL ALOHA CONDO MAP 284",
    "propertyAssessedValue": 440000,
    "registerSource": "hawaii_tax_licenses",
    "registerCheckedAt": "2026-09-26T21:40:12.000Z",
    "propertyType": "Entire rental unit",
    "roomType": "Entire home/apt",
    "city": "Honolulu",
    "latitude": 21.28616,
    "longitude": -157.83189,
    "personCapacity": 6,
    "bedrooms": 2,
    "rating": 4.67,
    "reviewsCount": 126,
    "hostName": "Kai",
    "hostType": "individual",
    "hostListingsCount": 3,
    "price": 1101,
    "currency": "USD",
    "pricePerNight": 220.2,
    "checkIn": "2026-10-10",
    "checkOut": "2026-10-15",
    "scrapedAt": "2026-09-26T21:40:12.513Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. The **Overview**, **Registered holders and owners**, **Register record**, **Hosts** and **Availability calendar** views of the Output tab show the main columns.

#### All 150 fields

| Fields | What you get |
| --- | --- |
| `id`, `source`, `url`, `title` | **Result**: Airbnb id (or the number given alone, or the register's number), `airbnb_listing` / `license_number` / `register_list`, link, title |
| `verdict`, `verdictReasons`, `verdictNote`, `isSuspicious`, `jurisdiction`, `state` | **Verdict**: see the table of verdicts below; the reasons found; one sentence; the city or county whose register applies; the US state |
| `registrationText`, `licenseNumber`, `licenseNumberNormalized`, `licenseType`, `otherLicenseNumbers`, `parcelNumber`, `exemption`, `numberSharedWith` | **Registration numbers**: the block as shown, the number checked as written and as the register writes it, its kind, the other numbers shown (TMK, TOT…), the parcel, the exemption claimed, the other listings of the run with the same number |
| `registerFound`, `registerNumber`, `registerUrl`, `registerName`, `registerType`, `registerStatus`, `registerStatusDate`, `registerIssuedDate`, `registerExpirationDate` | **Register**: found or not, the number (Los Angeles masks it), the link, the business name, the kind, the status and its date, issued, expires |
| `registerHolder`, `registerHolderType`, `registerHolders`, `registerHolderAddress`, `registerPhone`, `registerLocalContact`, `registerOwnerOrTenant`, `registerPrimaryResidence` | **Who**: the holder's full name, person or company, every holder / contact, the holder's address, phone and local contact (San Diego, Seattle), owner or tenant, lives there or not |
| `registerAddress`, `registerUnit`, `registerBuilding`, `registerPostalCode`, `registerCity`, `registerDistrict` | **Where the registration is**: the exact address, the unit, the building, ZIP code, city, council district or ward |
| `registerBedrooms`, `registerPlaces`, `registerUnits`, `registerTaxNumber`, `registerOtherAccounts`, `registerLocationStatus`, `registerHistory`, `registerListingUrl` | bedrooms and guests registered, units on the licence, tax number, the taxpayer's other accounts and the status of the rental location (Hawaii), earlier periods (Los Angeles), the listing link declared to the city (Cambridge) |
| `registerLatitude`, `registerLongitude`, `distanceKm`, `registerRaw`, `registerSource`, `registerCheckedAt` | position of the registered property, km to the listing, the register's own record untouched, which register, when it was read |
| `ownerNames`, `ownerMailingAddress`, `holderIsOwner`, `propertyLegalDescription`, `propertyAssessedValue`, `propertyLastSaleYear`, `propertyLastSalePrice` | **Property roll**: owners, where the tax bill is sent, whether the holder is one of them, legal description, assessed value, last sale |
| `propertyType`, `roomType`, `city`, `latitude`, `longitude`, `isExactLocation`, `locationText`, `locationDescription` | **Listing**: `Entire rental unit`, `Entire home/apt`, city, position (blurred by Airbnb), Airbnb's exact-location flag, area, the host's text about the neighbourhood |
| `personCapacity`, `bedrooms`, `beds`, `bathrooms`, `sleepingArrangements` | guests, rooms, where you'll sleep |
| `rating`, `reviewsCount`, `ratingAccuracy`, `ratingCheckin`, `ratingCleanliness`, `ratingCommunication`, `ratingLocation`, `ratingValue` | ratings out of 5 and number of reviews |
| `isSuperhost`, `isGuestFavorite`, `isNewListing`, `homeTier`, `badges`, `highlights` | Superhost, Guest favourite, new listing, tier, search badges, highlights |
| `description`, `descriptionLanguage`, `houseRules`, `houseRulesAdditional`, `amenities`, `images` | full description, its language, house rules, the host's additional rules, amenities, photo links |
| `hostId`, `hostName`, `hostUrl`, `hostType`, `hostIsVerified`, `hostYearsHosting` | **Host**: id, name, profile link, `business` / `individual`, verified, years hosting |
| `hostResponseRate`, `hostResponseTime`, `hostRating`, `hostReviewsCount`, `hostAbout`, `hostPictureUrl`, `hostLocation`, `coHosts` | response rate and time, rating and reviews over all their listings, presentation, photo, where they live, co-hosts |
| `hostListingsCount`, `hostListingIds` | **Host's listing count** (option): how many listings they manage, the IDs their profile shows (10 at most) |
| `calendarFrom`, `calendarTo`, `calendarNightsOpen`, `calendarNightsBlocked`, `calendarNightCap`, `calendarOverCap`, `calendarMinNights`, `calendarMonths`, `calendarDays` | **Availability calendar** (option): the nights counted (today to the end of the 11th month after this one), nights open, nights booked or blocked, the yearly cap of the city's law (Los Angeles: 120 days without an Extended registration), open past it in one calendar year, minimum stay, per month, per day |
| `riskScore`, `riskReasons`, `riskChecksSkipped` | **Risk score** (option): 0 to 100, the codes of the rules that gave it, the rules that could not play for lack of data |
| `proHostCompany`, `proHostWebsite`, `proHostEmails`, `proHostPhones`, `proHostContactSourceUrl`, `proHostContactConfidence` | **Professional host contact** (option): the company of a professional Airbnb host, its website, its business e-mails and phones, the page they come from, how sure the contact is |
| `photoFiles`, `photoSha256`, `photosDownloadedAt` | **Photos** (option): the public links of the photos kept in the run's storage, their SHA-256, the time they were downloaded |
| `comparables`, `comparablesMedianPrice` | **Comparables** (option): the nearest Airbnb listings of the same type within one bedroom (id, link, price per night, currency, bedrooms, rating, distance) and their median price per night |
| `estimatedNightsBooked12m`, `estimatedRevenue12m`, `estimatedOccupancy`, `revenueCurrency` | **Revenue estimate** (option): nights blocked in the calendar, their revenue at the price per night searched, the share of the calendar blocked, the currency |
| `aiLabels`, `aiLabelScores` | **AI labels** (option): five yes / no labels read in the description and the confidence behind each |
| `price`, `currency`, `pricePerNight`, `priceText`, `priceDetails`, `priceNights`, `checkIn`, `checkOut` | **Price** from the search results: total, currency, per night, as shown, breakdown, nights, dates |
| `searchUrl`, `scrapedAt` | the search the listing was found by, time of the check |

### 💡 Tips

#### What each verdict means

When a listing has several problems, its verdict is the highest one in this table, and `verdictReasons` lists them all.

| Verdict | Meaning |
| --- | --- |
| `valid` | The number is in the register of its place and active; the registered property is near the listing and the guests fit, where the register gives them (otherwise `verdictNote` says what could not be checked). |
| `not_in_register` | Not in the register: expired and removed, never registered, or a licence of another kind (Philadelphia). The registers list current registrations mostly, and do not say which. |
| `expired` | In the register but inactive, closed, delinquent, or past its expiry date (in the place's own day). |
| `location_closed` | Hawaii: the taxpayer's account is open but this rental location is closed for the transient accommodations tax. |
| `other_property` | The registered property is far from the listing (more than **Distance tolerance**), or the number belongs to another city's register. |
| `over_capacity` | The listing takes more guests than the registration allows (Cambridge). |
| `unknown_format` | The text shown is not a registration number of the place. |
| `no_number` | The listing shows no registration number (in Hawaii: a parcel number but no tax licence). |
| `exempt_claimed` | The listing says it is exempt (`Exempt`, `This listing is a hotel or motel`). |
| `jurisdiction_not_covered` | Outside the places checked (or a Hawaii County permit, not read): the number is given, not checked. |
| `register_unavailable` | The register could not be read in this run (or what came back was not the register as the Actor reads it: a changed page or column). |

#### How to cover a whole city

Airbnb shows at most 270 listings per search. With **Split full areas** on (default), a full search is cut into 4 smaller map areas, again and again, until each shows everything. A place's area is Airbnb's own map of it, which does not always cover the whole city: add **Map areas** (`boundingBoxes`) to be sure.

#### Risk score (option)

Tick **Risk score (0-100)** to get, for each Airbnb listing, one number from 0 (nothing wrong) to 100 and the codes of the rules behind it. The rules add their weights up, 100 at most, the verdict first:

| Rule (code in `riskReasons`) | Points |
| --- | --- |
| Verdict `not_in_register` (`verdict_not_in_register`) | 65 |
| Verdict `expired` (`verdict_expired`) | 60 |
| Verdict `location_closed` (`verdict_location_closed`) | 55 |
| Verdict `other_property` (`verdict_other_property`) | 55 |
| Verdict `no_number` (`verdict_no_number`) | 50 |
| Verdict `over_capacity` (`verdict_over_capacity`) | 40 |
| Verdict `unknown_format` (`verdict_unknown_format`) | 40 |
| Verdict `exempt_claimed` (`verdict_exempt_claimed`) | 20 |
| Verdict `jurisdiction_not_covered` (`verdict_jurisdiction_not_covered`) | 10 |
| The same number shown by another listing of the run (`number_shared`) | 20 |
| The registered address is more than 0.3 km from the listing (`distance_over_300m`) | 10 |
| An entire home (`entire_home`) | 5 |
| The host manages 3 listings or more (`host_3_or_more_listings`) / 2 listings (`host_2_listings`) | 25 / 10 |
| Open to short stays past the yearly night cap of the city (`over_night_cap`) | 25 |
| A business host, as Airbnb labels it (`trader_host`) | 20 |

The host's listings count only with **Host's listing count** ticked, the night cap only with **Availability calendar** ticked and only in a city that has a cap (Los Angeles: 120 nights a year without an Extended registration): a rule whose data is not read is skipped, named in `riskChecksSkipped`, and never counted as a risk. A distance the register cannot give (number not found, or a register without a position) is skipped the same way. When the register could not be read in the run (`register_unavailable`) there is nothing to score: no score, nothing charged. A number given alone and a record of a whole register get no score. It is a guide to which listings to look at first, not a finding of fault.

#### Professional host contact (option)

Airbnb shows no e-mail or phone for most hosts, and the US registers give the holder's contact only where their own rules publish it (San Diego, Seattle). Tick **Professional host contact** to get the **business email and phone of professional hosts, from publicly available sources**: `proHostEmails` and `proHostPhones` (3 each at most, phones as `+1 808 555 0100`), with `proHostContactSourceUrl` (the page they were read from), `proHostCompany` and `proHostWebsite`, and `proHostContactConfidence` (`high` when an e-mail is on the company's own domain, `medium` otherwise). A host is looked up only when a company name is known: a host or co-host whose name is a company's. A host with a person's name only is never looked up, whatever Airbnb's label (business or individual) or the number of listings. A company is looked up once per run and per state, however many listings it has, and its site must name the company and place it where the listing is. When no contact is found, the listing is delivered as it is and not charged; you pay `pro-host-contact` once per listing whose row carries an e-mail or a phone. Not available with **Cards only (fast)**.

#### Photos (option)

Tick **Download photos** to keep a copy of the first photos of each listing (**Max photos per listing**, 5 by default) in the key-value store of the run: `photoFiles` gives the public link of each, `photoSha256` its SHA-256 and `photosDownloadedAt` the time of the download — a dated proof of what the listing showed that day. The links to the photos on Airbnb (`images`) stay in every run, free. Only Airbnb's own photos are downloaded. A photo that cannot be had (gone, too big, not an image) is left out and is not charged: the listing is delivered with the ones that came. You are charged `photo-download` once per photo delivered. Photos weigh about 230 KB each: a run of 1,000 listings with 5 photos fills about 1 GB of storage. A licence number given alone and a register record have no photos.

#### Cards only (option)

Tick **Cards only (fast)** to get just what Airbnb shows in its search results, without opening the listings: the link, title, type of place (`propertyType`: Apartment, Condo…), price, rating, position, bedrooms and the dates of the search. It is faster and cheaper than a full check, and the right choice to list or monitor what is offered; the rows have `source` set to `airbnb_card` and `verdict` set to `unchecked` — **no registration number, no verdict, nothing from the register**. A run in this mode is charged one `listing-card` per card, and nothing else (no check fee for a card your filters drop: minimum rating (a card without a rating is dropped), excluded words and the dates and prices of the search still apply). US cards carry no host type, so **Host type** cannot sort them: the cards are all kept, with no host type judged.

It needs a place, a map area or an Airbnb search URL. It cannot be mixed with what needs the listing page or the register — host profile, calendar, risk score, revenue estimate, comparables, AI labels, property owner, listing URLs and IDs, licence numbers, register lists, and the filters on verdicts, places, holder type and phone: the run is refused at the start, naming each one.

#### Comparables (option)

Tick **Comparable listings** to get, for each Airbnb listing, `comparables`: the Airbnb listings around it that are of the same type of place (entire home, private room…) and within one bedroom of it, the nearest first, up to **Max comparables per listing** (10 by default) — each with its link, `pricePerNight`, `bedrooms`, `rating` and `distanceKm` — and `comparablesMedianPrice`, their median price per night. Give **Check-in** and **Check-out** to get the prices (the nightly rate of those dates, before taxes and fees, in the currency of the run); without dates the neighbours carry no price and there is no median.

The neighbours are read from the search results around the listing, in the listing's own city, not from their own pages, and one search serves all the listings of the same area (about 500 m), type of place and size: a run over a whole district costs a few searches, not one per listing (a district with every size of home costs one search per type of place and size). Airbnb shows the 18 best results of an area, so the neighbours are those of that page that fit: a quiet area may give fewer than the maximum; a listing whose type, position or city is unknown, or an entire home whose bedrooms are unknown, gets none. A listing is charged `comparables` only when its row carries at least one neighbour; a licence number given alone and a register record get none.

#### Revenue estimate (option)

Tick **Revenue estimate (12 months)** and give **Check-in** and **Check-out** to get, for each Airbnb listing found by a search, an estimate of what its calendar says it earns: `estimatedNightsBooked12m` (the nights of the calendar that are not open), `estimatedRevenue12m` (those nights × the `pricePerNight` of the dates searched, in `revenueCurrency`) and `estimatedOccupancy` (the share of the calendar blocked, 0 to 1). The option reads the listing's calendar (the same one as **Availability calendar**, charged as such) — but only when the run has dates: without them no card has a price per night and nothing would be estimated.

It is an **estimate**: a night the calendar shows as not open may be rented or simply closed by the host, Airbnb does not tell them apart (the figure is an upper bound of the nights rented), and the price is the average nightly rate of the dates you searched, not of the year. A listing given by URL or ID has no price per night: it gets no estimate and is not charged for one. A licence number given alone and a register record get none. The log counts the listings estimated and those left without.

#### AI labels (option)

Tick **AI labels** to have the description of each Airbnb listing read for five things, each a yes / no in `aiLabels` with its confidence (0 to 1) in `aiLabelScores`:

| Label (key) | What it says | True from |
| --- | --- | --- |
| `managed_by_company` | The listing is run by a company or a property manager | 0.50 |
| `self_check_in` | Guests check in by themselves (lockbox, keypad, code) | 0.60 |
| `long_stay` | Monthly or long stays (28 nights or more) | 0.50 |
| `not_principal_residence` | The host does not live in the home | 0.75 |
| `mentions_licence` | The text mentions a licence or a permit (not the registration block Airbnb adds) | 0.50 |

The labels are read in the host's own text and are **indications, not facts**: the cut-offs are set high so that a label marked true is rarely wrong, and a host who does not write it down gets `false` (a long description is read to its end, up to about 6,000 characters). `not_principal_residence` is the one to read next to the rules of the city you check: some cities allow short-term rentals of the host's own home only. The cut-offs were set on 40 English descriptions read by hand, in October 2026 — a small sample: expect some misses and some false alarms. Only English descriptions are read: another language, a licence number given alone, a register record or a listing without a description gets `null` and is not charged. The option needs **2 GB of memory** (Run options → Memory): on a smaller run it is skipped, the log says so, and nothing is charged. The descriptions are read one at a time, so a run with the option is slower and costs more compute; it is charged once per listing given its labels.

#### How to reduce costs

The levers are `maxItems`, `maxItemsPerQuery`, **Keep only these verdicts** (a result dropped costs only the filter fee), using **Cards only (fast)** when you do not need the number, leaving **Host's listing count**, **Availability calendar**, **Risk score (0-100)**, **Revenue estimate (12 months)**, **Comparable listings**, **Download photos**, **Professional host contact**, **AI labels** and **Property owner** off unless you need them, and `onlyNew` for recurring runs (you never pay twice for the same listing).

#### Several searches in one run

Fill `locations` and / or `boundingBoxes`, or paste several search URLs: one search each (up to 100 places, 100 map areas and 1,000 URLs per run). A listing found by several searches is saved — and charged — once. Set `maxItemsPerQuery` to give every search its own cap.

#### Monitoring: only the new listings

Tick **Only new listings** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips what was already delivered: not saved, not charged, and the listing page is not even opened. The memory lives in a named key-value store of your account (`airbnb-us-license-checker-seen`, up to 150,000 listings per key) and is only updated with results that really reached the dataset, plus, apart, the ones your filters dropped: a result your filters drop is checked (and charged) once; the next runs with the same filters skip it for free. Change a filter, or tick `resetState`, to check them again. Give each schedule its own `stateKey`, and tick `resetState` once to start over. With **Register lists**, a scheduled run returns the new registrations of the cities. A result saved while its register could not be read (`register_unavailable`) is not remembered, saved or dropped: the next run checks its number, and charges it, again.

#### What the registers can and cannot say

| Place | Number on Airbnb | Holder named | Exact address | More |
| --- | --- | --- | --- | --- |
| Hawaii (Oahu, Maui, Kauai, Hawaii Island) | TMK + state tax licence (`TA-…`) | the taxpayer, all islands | Honolulu: building and unit from the property roll (option **Property owner**) | account and location status, other tax accounts; Honolulu: owners, tax bill address, value (option **Property owner**) |
| Los Angeles | `HSR25-000906` | the registered host | yes | owner or tenant, parcel, history of periods |
| San Diego | `STR-13904L` | the host and the local contact | yes | local contact's phone, tier, TOT number |
| Chicago | `R26000144381` or 7 digits | the host (vacation rental: the business) | yes, with unit | ward, precinct |
| Denver | `2025-BFN-0011695` | no (the property roll names the owner, option **Property owner**) | yes | owner, last sale, value (option **Property owner**) |
| Seattle | `STR-OPLI-22-000938` | the business behind the operator licence | yes, with unit | business phone, bedrooms, primary residence |
| Philadelphia | a bare 6-7 digits | yes | yes | owner of record, units |
| Austin | `OL 2025 121818` | no | yes | type of rental |
| Cambridge | `STR-1155446` | the applicant | yes, with unit | guests allowed, the listing link declared |

A place outside these gets `jurisdiction_not_covered`: its number is given, not checked. New York, Orlando and many cities show no number on Airbnb.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per Airbnb listing checked (or per registration number, or per register record). Actor id: `nice_dev/airbnb-us-license-checker`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/airbnb-us-license-checker`.

Smallest input, for a cheap first call:

```json
{
    "licenseNumbers": ["HSR25-000906"],
    "location": "Kihei, HI",
    "maxItems": 5
}
```

Key output fields: `url`, `verdict`, `verdictNote`, `licenseNumber`, `registerHolder`, `registerAddress`, `ownerNames`, `hostName`.

Cost: see the prices on the Pricing tab. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Airbnb and use the registers?

The Actor only reads what Airbnb shows publicly to any anonymous visitor, and the public records the cities, counties and the State of Hawaii publish (open data portals, public search pages; each result names its register). It logs in to nothing. Chicago's data: "This site provides applications using data that has been modified for use from its original source, www.cityofchicago.org, the official website of the City of Chicago. The City of Chicago makes no claims as to the content, accuracy, timeliness, or completeness of any of the data provided at this site." Results contain personal data (names and addresses of hosts, holders and owners, phones of local contacts): do not store or use it without a legitimate reason, and follow the laws that apply to you (US state privacy laws, FCRA, GDPR). The business e-mail and phone of the **Professional host contact** option are contact details of companies, taken from publicly available sources, with the page each one comes from; the option never looks up a private person, and sending commercial messages to them is governed by the law that applies to you (in the US, the CAN-SPAM Act and state laws): you answer for how you use them. You are responsible for using the data in compliance with Airbnb's Terms of Service, each register's terms and applicable law. This Actor is not affiliated with Airbnb or with any US city, county or state.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Is the data safe to open in Excel or to show on a web page?

Titles and descriptions are the hosts' own words, copied as they are; the register fields are copied as each register writes them. A text can begin with `-`, `+`, `=` or `@` (a phone number can start with `+`): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number, and a ZIP code such as `02139` loses its first `0`. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. On a web page, escape every field like any text written by a stranger.

#### Known limitations

- The price comes from the search results: listings given by URL or ID have none.
- Los Angeles masks the registration number in its answer (`HSR25-****06`); a slow answer is read again before a number is called absent.
- Hawaii's tax register gives no address for private persons: the unit and owners come from Honolulu's property roll only (the other islands' rolls are not read).
- A host profile shows 10 of its listings at most: `hostListingsCount` is the full count, `hostListingIds` the first ones.
- The calendar shows nights open, not nights booked: `calendarOverCap` says a Los Angeles listing is offered on more short-stay nights than its cap in one calendar year — the nights already hosted earlier that year are not seen. A booked night and a night the host blocked look the same.
- `onlyNew` remembers ids, not their content: a listing whose registration changed is not returned again.

**A run the platform stops without warning** (out of memory, run timeout)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the results already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the results it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the results of its last 2 seconds once more.

#### Something doesn't work?

The last line of the log counts the results saved, filtered out and no longer on Airbnb (removed while the run was reading them), and the requests that failed after every retry. Those requests and the removed listings are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause. A register that cannot be read does not fail the run: its listings get `register_unavailable`, the run's last message counts them, and `onlyNew` does not remember them — the next run checks them again. A listing whose register is slow to answer is read again once the answer is there (the log says `… could not be completed in its handler's time: read again`): nothing is lost or charged twice.

If Airbnb changes its pages, you are told instead of paying for blank rows. A results page that gives no listing the Actor can read is an error (listed in `FAILED_REQUESTS`), never a quiet "No listings found". If the first 20 listings read all lack their title, position, price (listings found by a search), guests, room type, host or photos, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first listings are charged. A listing a filter drops because such a field is missing counts among those 20. The registration block is judged the same way, on the listings a search found in the places covered (hotels aside), once so many of them lack it that no real search would: 6 in Honolulu, 17 in Austin, where most hosts show none (up to 100 listings read). Listings you paste are never counted: a run of listings without a number is a normal run.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which URLs failed and why.

# Actor input Schema

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

Airbnb listing URLs (`https://www.airbnb.com/rooms/12345`, any Airbnb domain) and/or Airbnb search URLs (`https://www.airbnb.com/s/Honolulu--HI/homes`, map searches included: their filters are kept, pagination and map splitting are automatic). Max 1 000 URLs.

## `listingIds` (type: `array`):

Airbnb listing IDs alone (the digits after `/rooms/`), one per line — checked in this order, before any search: with a result limit, the first ones are the ones saved. Max 1 000.

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

A place in the United States, as typed in Airbnb's search box (e.g. `Honolulu, HI`, `Los Angeles, CA`, `Chicago, IL`, `San Diego, CA`, `Maui, HI`). Each listing found is opened and the number it shows is checked in the register of its city or county (see **Places covered**); listings elsewhere are saved with their number, not checked.

## `locations` (type: `array`):

Several places in one run (one Airbnb search each, max 100). Added to **Place**; a listing found by several searches is saved once.

## `boundingBoxes` (type: `array`):

Map rectangles to search, one per line as `south latitude, west longitude, north latitude, east longitude` (e.g. `21.26, -157.84, 21.29, -157.81` for Waikiki). The surest way to cover a whole city: Airbnb returns at most 270 listings per search, and a full area is split into smaller ones automatically.

## `licenseNumbers` (type: `array`):

Registration or licence numbers checked in the registers without any Airbnb listing (e.g. `HSR25-000906`, `R26000144381`, `TA-201-566-9248-02`, `2025-BFN-0011695`, `STR-OPLI-22-000938`, `STR-13904L`). The register is picked from the number's format; a bare number that fits two registers (7 digits: Chicago vacation rental or Philadelphia licence) can be prefixed with the city (`Chicago: 3056909`), otherwise both registers are checked. One result per number; several numbers in one entry (separated by commas, semicolons or line breaks) count one each. Max 1 000 numbers.

## `registerLists` (type: `array`):

Every short-term rental registered in these cities, read straight from the city's open register — address, and where the register gives them holder, status and expiry (Austin: address and type only; Denver: no holder; phone of the local contact in San Diego) — without any Airbnb search. Hawaii has no list (its tax licences are searched by number only). Newest registrations first where the register has a date.

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

Maximum number of results (listings checked + licence numbers + register records) to save for the whole run, after filters. 0 = no limit.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH search (place, map area or search URL) and each whole register, so that the first one cannot use up the whole **Max results** budget. 0 = no per-search cap.

## `splitMap` (type: `boolean`):

Airbnb shows at most 270 listings (15 pages) per search. When a search is full, cut its map area into 4 smaller areas, again and again, to reach the listings beyond 270. Off = the first 270 of each search only.

## `cardsOnly` (type: `boolean`):

Deliver the card of each Airbnb search result — link, title, type of place, price, rating, position, bedrooms — without opening the listing: faster and cheaper, but no registration number, no verdict, nothing from the register. Charged per card (see Pricing), nothing else is charged in this mode. Needs a place, a map area or an Airbnb search URL. Min rating and Exclude keywords apply to the cards; Host type does not (US cards do not say it). Not compatible with the options that read the listing or the register (host profile, calendar, risk score, revenue estimate, comparables, photos, professional host contact, AI labels, property owner), with Airbnb listing URLs and IDs, licence numbers and register lists, nor with the filters on verdicts, places, holder type and phone.

## `checkIn` (type: `string`):

Travel dates of the search (`2027-07-12`). Airbnb then shows the listings free on those dates and their price for the stay; empty = Airbnb's own flexible dates. Today or later (the day in Hawaii, the latest US time zone): Airbnb shows nothing for a stay that has begun.

## `checkOut` (type: `string`):

End of the stay (`2027-07-15`), after the check-in date.

## `adults` (type: `integer`):

Number of guests: only the listings that can host them. 0 = any.

## `children` (type: `integer`):

Children aged 2-12 travelling (Airbnb filter). 0 = none.

## `infants` (type: `integer`):

Infants under 2 travelling (Airbnb filter). 0 = none.

## `pets` (type: `integer`):

Pets travelling: only listings that allow pets. 0 = none.

## `currency` (type: `string`):

Currency of the prices shown on the search results.

## `priceMin` (type: `integer`):

Lowest price per night, in the currency above. 0 = no minimum.

## `priceMax` (type: `integer`):

Highest price per night, in the currency above. 0 = no maximum.

## `roomTypes` (type: `array`):

Only these kinds of place. Empty = all.

## `propertyTypes` (type: `array`):

Only these kinds of property (Airbnb filter). Empty = all.

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

Only listings with at least this many bedrooms. 0 = any.

## `minBeds` (type: `integer`):

Only listings with at least this many beds. 0 = any.

## `minBathrooms` (type: `integer`):

Only listings with at least this many bathrooms. 0 = any.

## `superhostOnly` (type: `boolean`):

Only listings of Superhosts (Airbnb filter).

## `registeredAfter` (type: `string`):

Only registrations issued on this date or later (`2026-01-01`, or `30 days`): the new hosts of the city. Seattle, San Diego and Austin give no issue date: this filter does not apply to them (every registration is listed, the log says so). Los Angeles: the date of the first registration, not of a renewal. Chicago: the year in the number (R26… = 2026) and the date of its last status change. Empty = all.

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

Only registrations the register marks active / approved / complete and not past their expiry date. Untick for expired and closed ones too.

## `onlyVerdicts` (type: `array`):

Save only the listings whose verdict is one of these — e.g. `expired`, `location_closed`, `not_in_register`, `other_property`, `over_capacity`, `unknown_format` and `no_number` to get the suspicious listings only (the verdicts marked isSuspicious). Empty = every listing.

## `jurisdictions` (type: `array`):

Only listings located in these cities or counties (a licence number or register record: its register). Empty = all, including listings outside the covered places (saved with the number they show, not checked).

## `holderType` (type: `string`):

Only results whose registered holder is a private person or a company (LLC, Inc, Trust…), read from the holder's name or the register's own entity type (Philadelphia, Seattle).

## `onlyWithPhone` (type: `boolean`):

Only results with a phone number from the register: the local contact in San Diego (every licence), the business phone in Seattle. Other registers publish no phone, so this keeps San Diego and Seattle only.

## `hostType` (type: `string`):

Only listings of business hosts or of individual hosts, as Airbnb labels them on the search results (on the listing page for listing URLs and IDs).

## `minRating` (type: `number`):

Only listings rated at least this much out of 5 (listings without a rating are dropped). 0 = any.

## `excludeKeywords` (type: `array`):

Drop the listings whose title contains one of these words (case and accents ignored).

## `gpsToleranceKm` (type: `number`):

Airbnb blurs a listing's position by a few hundred metres. A registered property farther than this from the listing gives the verdict `other_property` (registers with a position: San Diego, Seattle, Cambridge, Chicago vacation rentals; Hawaii: its tax register gives no position).

## `includeOwner` (type: `boolean`):

Add the property owner(s) from the county property roll, with the tax bill mailing address and assessed value — Honolulu (from the TMK the listing shows: also the building and unit number) and Denver (from the licence's parcel, with the last sale). 4 requests per Honolulu parcel and 1 per Denver parcel, each parcel read once per run; `holderIsOwner` tells whether the registered holder owns the property. Charged per result that comes with the property roll (see Pricing); a result the roll gives nothing for costs nothing extra. Philadelphia's owner of record comes with its register, at no extra cost.

## `includeHostProfile` (type: `boolean`):

Open the host's public profile (1 extra request per host, not per listing) for the number of listings they manage and their IDs. Charged per host profile (see Pricing).

## `includeCalendar` (type: `boolean`):

Read each Airbnb listing's calendar (1 extra request per listing): nights open and nights booked or blocked from today to the end of the 11th month after this one (Airbnb's 12 calendar months), per month and per day. In Los Angeles, also whether the listing is open to short stays on more than the 120 days a calendar year Home-Sharing allows without an Extended registration. Charged per listing whose calendar reaches your results (see Pricing).

## `includeRiskScore` (type: `boolean`):

Give each Airbnb listing a risk score from 0 to 100 and the short codes of the rules behind it: the verdict first, then a number shown by several listings, a registered address far from the listing, an entire home, a host who manages several listings (needs **Host's listing count**), a calendar open past the yearly night cap of the city (needs **Availability calendar**; Los Angeles only) and a business host. A rule whose data is not read is skipped and named, never counted as a risk. No extra request. Charged per listing whose row carries a score (see Pricing); a row whose register could not be read gets none and is not charged for it.

## `includeAiLabels` (type: `boolean`):

Label each Airbnb listing's description with five yes / no AI labels and their scores: managed by a company or a property manager, self check-in with a lockbox or a keypad, monthly or long stays (28 nights or more), host does not live in the home, mentions a licence or a permit. English descriptions only: a description in another language, a licence number given alone, a register record and a listing without a description get none. The labels are read in the text of the description, they are indications, not facts. Needs 2 GB of memory (Run options → Memory): with less, the AI labels are skipped, said in the log, and nothing is charged. The descriptions are read one at a time, so a run with this option is slower. Charged per listing whose row carries its labels (see Pricing).

## `includeRevenueEstimate` (type: `boolean`):

Estimate the revenue of each Airbnb listing from its availability calendar: the nights the calendar shows as not open (booked, or closed by the host — Airbnb does not tell them apart) × the price per night of the dates searched, with the share of the calendar that is blocked. An estimate, not what the host earned. Needs **Check-in** and **Check-out** (the price per night comes from a search with dates; a listing given by URL or ID has none) and reads the calendar too, charged as **Availability calendar**. A listing without a price per night gets no estimate and is not charged for one. Charged per listing whose row carries its estimate (see Pricing).

## `includeComparables` (type: `boolean`):

Add, to each Airbnb listing, the Airbnb listings around it: the nearest ones of the same type of place and within one bedroom of it (up to **Max comparables per listing**), each with its price per night, rating, bedrooms and distance, and the median price per night of them. Searched in the listing's own city. Read from the cards of a search around the listing: no listing page is opened, and one search serves every listing of the same area, type of place and size. An entire home whose bedrooms are unknown gets none. Give **Check-in** and **Check-out** to get prices: without dates the comparables have no price and there is no median. Charged per listing whose row carries comparables (see Pricing).

## `maxComparablesPerListing` (type: `integer`):

Most comparable listings kept for each listing (**Comparable listings**): the nearest ones.

## `downloadPhotos` (type: `boolean`):

Download the first photos of each listing into this run's key-value store and give their public links, their SHA-256 and the time of the download: a dated copy of what the listing showed that day. The links in **Photos** (`images`) stay in every run for free. A photo that cannot be had (gone, too big, not an image) is left out and not charged. Charged per photo delivered (see Pricing). Not available with **Cards only (fast)**.

## `maxPhotosPerListing` (type: `integer`):

Photos downloaded for each listing (**Download photos**): the first ones of the listing.

## `includeProHostContact` (type: `boolean`):

Add the business e-mail and phone of professional Airbnb hosts, from publicly available sources, with the page each comes from and a confidence: `proHostEmails`, `proHostPhones`, `proHostContactSourceUrl`, `proHostContactConfidence`. A host is looked up only when a company name is known (a host or co-host whose name is a company's), never a private person. Charged per listing whose row carries a contact (see Pricing); a listing with none is delivered as it is, not charged. Not available with **Cards only (fast)**.

## `onlyNew` (type: `boolean`):

Skip the listings (licence numbers, register records) that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their page is not even opened. First run = everything is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new listings**. Give each schedule / task its own key (e.g. `honolulu-weekly`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every listing again. Untick it afterwards.

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

Apify Proxy or your own proxies, for the Airbnb pages and the registers. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

## `maxConcurrency` (type: `integer`):

Maximum number of Airbnb pages processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to Airbnb in any 60 seconds, all of them counted: search pages, listing pages and host profiles. A budget, not an even pace: up to this many can leave at once when the minute starts (spread them with the minimum delay below). Lower it if Airbnb answers HTTP 429 / 403 in the log.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests to Airbnb, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked as failed. Behind a proxy, a request Airbnb turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "listingIds": [],
  "location": "Honolulu, HI",
  "locations": [],
  "boundingBoxes": [],
  "licenseNumbers": [],
  "registerLists": [],
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "splitMap": true,
  "cardsOnly": false,
  "adults": 0,
  "children": 0,
  "infants": 0,
  "pets": 0,
  "currency": "USD",
  "priceMin": 0,
  "priceMax": 0,
  "roomTypes": [],
  "propertyTypes": [],
  "minBedrooms": 0,
  "minBeds": 0,
  "minBathrooms": 0,
  "superhostOnly": false,
  "activeOnly": true,
  "onlyVerdicts": [],
  "jurisdictions": [],
  "holderType": "any",
  "onlyWithPhone": false,
  "hostType": "any",
  "minRating": 0,
  "excludeKeywords": [],
  "gpsToleranceKm": 1.5,
  "includeOwner": false,
  "includeHostProfile": false,
  "includeCalendar": false,
  "includeRiskScore": false,
  "includeAiLabels": false,
  "includeRevenueEstimate": false,
  "includeComparables": false,
  "maxComparablesPerListing": 10,
  "downloadPhotos": false,
  "maxPhotosPerListing": 5,
  "includeProHostContact": false,
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 120,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

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

No description

# 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 = {
    "location": "Honolulu, HI",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/airbnb-us-license-checker").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 = {
    "location": "Honolulu, HI",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/airbnb-us-license-checker").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 '{
  "location": "Honolulu, HI",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/airbnb-us-license-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/airbnb-us-license-checker"
        }
    }
}
```

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/HtgbNAScpuSquOiQJ/builds/wVCYHjk535cOg0wZt/openapi.json