📇 Airbnb Host Contact & Lead Scraper Plus

Airbnb Host Scraper — Extract Host, Listing and Experience Contacts

Airbnb Host Contact & Lead Scraper Plus finds Airbnb listings, hosts, and experiences through targeted Google searches and pulls any genuine, confidence-tagged phone number or email address out of the public search snippet — never a fabricated one. Every row also carries reliable entity identity: the listing ID, host user ID, or experience ID parsed straight from the Airbnb URL, plus the host's profile link. Unlike scraping frameworks that return raw HTML, the Actor returns typed JSON — ready for your CRM, your outreach tool, or your database without any parsing. This guide covers exactly what the Actor extracts, how the contact-confidence system works, and how outbound and market-research teams deploy it in production.

🧭 What Does Airbnb Host Contact & Lead Scraper Plus Do?

Airbnb Host Contact & Lead Scraper Plus is a Google-SERP ("dork") lead-generation Actor for Airbnb. It does not log into Airbnb or fetch Airbnb pages directly for search results — it builds a site:airbnb.com Google query per keyword, paginates the results, and parses each result snippet for entity identity plus any phone number or email address that genuinely appears in the text. It also accepts direct Airbnb URLs (listing, host, or experience) and turns each one into an identity row without touching Google at all. No Airbnb account or login is required for either mode — the source code contains no authentication step.

• 🔍 Google-dork keyword search across site:airbnb.com, seeded with a country dial code
• 🔗 Direct-URL mode for /rooms/, /users/show/, and /experiences/ links
• 🏷️ Entity classification into room, user, experience, or other
• 📞 Confidence-tagged phone extraction (high for internationally-prefixed numbers, medium for plausible national numbers) with zero fabrication
• ✉️ Email extraction from the same snippet text
• 🧹 Canonical-URL deduplication within a run, and optionally across runs via a persisted key-value store
• 🎯 Post-search filtering by contact presence, entity type, and include/exclude keyword lists

⚡ Features & Capabilities

The Actor's feature set splits into what it extracts, how it stacks up against the other Airbnb contact scrapers on the Apify Store, and where it deliberately draws the line.

Core features

• Three entity types from one Actor — airbnbEntityType is set to room (listing), user (host profile), or experience, parsed by regex from the canonical Airbnb URL (/rooms/, /luxury/listing/, /users/show/, /experiences/).
• Never-fabricated phone extraction — the extraction module will only accept a phone number when the source snippet itself carries a genuine + or 00 international prefix (phoneConfidence: "high"), or, in loose mode, a clearly phone-formatted national number of plausible length for the selected country (phoneConfidence: "medium"). A bare digit run — a listing ID, a price, a coordinate — is never turned into a phone number.
• Every phone number kept, not just the first — allPhoneNumbers carries every distinct number found in the snippet; phoneE164 surfaces the first as the primary field.
• Email extraction — email and allEmails, deduplicated and lowercased, with image-file false positives (.png, .jpg, etc.) filtered out.
• Entity identity with 100% reliability — listingId, hostUserId, experienceId, and hostProfileUrl are parsed directly from the URL structure, not inferred, so they are present on every row regardless of whether a contact was found.
• Full search provenance — keyword, googleQuery, serpRank, serpPage, inputMode, and scrapedAt are attached to every row so you can trace exactly which query produced it and when.
• Cross-run memory — when dedupAcrossRuns is on, canonical URLs already emitted are persisted in a named key-value store (airbnb-contact-dedup) so a repeat run only surfaces new entities.

How Airbnb Host Contact & Lead Scraper Plus compares to other Airbnb scrapers

Feature	Airbnb Host Contact & Lead Scraper Plus	Airbnb Host Contact Details Scraper (scrapyspider)
Output format	Typed JSON, fixed 23-field schema	JSON / CSV / Excel via Apify dataset export (as observed on the Apify Store on 2026-07-26)
Discovery method	Google-dork keyword search + direct URL input	Direct host-profile URL input only (as observed on the Apify Store on 2026-07-26)
Full profile/listing page fetch	No — snippet-only, by design	Yes — fetches the host profile page for ratings, reviews, Superhost status, and listing description (as observed on the Apify Store on 2026-07-26)
Phone fabrication safeguard	Explicit — bare digit runs are rejected, confidence-tagged output	Not documented
AI-assisted parsing	Not offered	Optional OpenAI-powered structured extraction (as observed on the Apify Store on 2026-07-26)
Entity types covered	Listing, host, and experience	Host profile only (as observed on the Apify Store on 2026-07-26)
Cross-run deduplication	Built in, persisted key-value store	Not documented

If your use case is feeding structured data to an LLM or a CRM import job, the output-format row is the decision-maker — HTML parsing or ambiguous phone fields inside an agent loop is a reliability failure mode, not a feature. Airbnb Host Contact & Lead Scraper Plus is not the better choice for every job, and the section below says where.

When another tool might suit you better

If what you actually need is a full host profile — ratings, review counts, years hosting, Superhost/Identity-verified badges, and business registration numbers — pulled from the host's own profile page rather than a Google snippet, the scrapyspider Airbnb Host Contact Details Scraper does that page fetch and also offers optional OpenAI-assisted parsing, as observed on the Apify Store on 2026-07-26. This Actor deliberately does not fetch Airbnb pages for search results, so it cannot return ratings, review counts, or badge data at all — only what a Google snippet contains plus the entity IDs.

Airbnb Host Contact & Lead Scraper Plus within the Scrapio data stack

Airbnb Host Contact & Lead Scraper Plus covers host, listing, and experience contact and lead identity. For full listing data — pricing, fees, amenities, host details, and guest reviews pulled directly from Airbnb — use Scrapio's Airbnb Scraper — Listings, Fees, Host & Reviews. For enriching a discovered host's own website with additional contact emails once you have a URL, pair this Actor with Scrapio's Website Contact & Email Crawler.

Why do developers and data teams scrape Airbnb?

🏢 Property management and real estate outreach

Agencies and software vendors selling to professional Airbnb hosts run keywords like "property management" or "co-hosting" with requireContact: true to get only rows carrying a real phoneE164 or email. Each row lands with listingId or hostUserId, the snippet title and description for context, and country/dialCode for territory targeting — enough to load straight into an outreach sequence without manual lookup.

📊 AI training data and RAG indexing

The description field carries free-text search-snippet content — property type, location cues, and host-service language — which makes it the field worth chunking for RAG enrichment of a short-term-rental knowledge base. For training data, airbnbEntityType, phoneConfidence, and inputMode are consistently typed across every row (string enums, never mixed types), so they need no normalization before going into a feature pipeline. Two concrete uses: enriching a rental-market RAG index with real snippet text tied to a canonical url, and building a labeled dataset of confidence-tagged contact extractions for training a downstream extraction model.

📱 Competitive and market intelligence

Track how densely a keyword like a management-company brand name or a neighborhood term appears in Airbnb's Google footprint over time by running the same keywords list on a schedule and watching serpRank and serpPage move, or watching for new url values entering the dataset.

🔬 Research and academic use

allPhoneNumbers, allEmails, and airbnbEntityType support studies of professional-host contactability and platform intermediation, using only what Google has already indexed as publicly accessible.

🎥 Product and SaaS development

Directory and lead-enrichment products can key off hostUserId/listingId plus the contact fields to build a professional-host contact database, refreshing it on a schedule and relying on dedupAcrossRuns to avoid re-selling the same lead twice.

🍚 Input Parameters

All 12 parameters, exactly as defined in .actor/actor.json. Only country is required.

Parameter	Required	Type	Default	Description
keywords	No	array of strings	["property management"] (prefill)	Keywords used to build the Google dork site:airbnb.com "+<dialcode>" "<keyword>". Leave empty if you only use startUrls.
startUrls	No	array of strings	[]	Direct Airbnb listing (/rooms/ID), host (/users/show/ID), or experience (/experiences/ID) URLs. These skip Google and emit entity identity only.
country	Yes	string (enum)	"United Kingdom (+44)"	The country whose dial code is added to the Google dork and used for phone plausibility checks. Does not filter results by geography. A dropdown of 190+ countries with their international dial codes, e.g. "United States (+1)", "Germany (+49)", "India (+91)", "Australia (+61)" — the full enum is available in the Actor's Input tab in Apify Console.
maxResultsPerKeyword	No	integer	20	Stop paginating a keyword's Google results after this many rows are emitted (after dedup + filters). Min 1, max 10000.
maxResults	No	integer	0	Hard cap on total rows across all keywords and URLs in this run. 0 means unlimited. Min 0.
requireContact	No	boolean	false	When enabled, emit only rows that have a genuine phone or email; drops entity-identity-only rows.
phoneCountryStrict	No	boolean	true	Strict (default, recommended): only accept numbers with a genuine + or 00 country prefix in the snippet (phoneConfidence: "high"). Loose: additionally accept phone-formatted national numbers of plausible length (phoneConfidence: "medium"). A bare digit run is never fabricated into a phone in either mode.
entityTypes	No	array (select)	[]	Keep only these Airbnb entity types: room (Listing / room), user (Host / user profile), experience (Experience), other (Other). Leave empty for all.
includeKeywords	No	array of strings	[]	Keep a row only if its title or snippet contains at least one of these terms (case-insensitive). Applied after the Google search.
excludeKeywords	No	array of strings	[]	Drop a row if its title or snippet contains any of these terms (case-insensitive).
dedupAcrossRuns	No	boolean	true	Dedup rows by canonical Airbnb URL. Always dedups within a run; when enabled, also remembers URLs from previous runs (persisted in a named key-value store) so repeat runs don't re-emit the same entity.
proxyConfiguration	No	object	{"useApifyProxy": true, "apifyProxyGroups": ["GOOGLE_SERP"]}	Proxy settings for Google SERP fetches. See the note below — the proxy group is not actually configurable from this field.

⚠️ proxyConfiguration.apifyProxyGroups is accepted but ignored. The source code always forces the Apify GOOGLE_SERP proxy group for every Google fetch, regardless of what proxy group list you pass in. Only the useApifyProxy boolean inside this object is actually read. Direct-URL mode makes no HTTP fetch at all, so proxy settings don't apply to it.

Example input

{
  "keywords": ["property management", "superhost"],
  "startUrls": ["https://www.airbnb.com/rooms/53422981"],
  "country": "United Kingdom (+44)",
  "maxResultsPerKeyword": 20,
  "maxResults": 0,
  "requireContact": false,
  "phoneCountryStrict": true,
  "entityTypes": [],
  "includeKeywords": [],
  "excludeKeywords": [],
  "dedupAcrossRuns": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["GOOGLE_SERP"] }
}

Supported URL types and input formats

startUrls accepts three Airbnb URL shapes, matched by regex against the raw URL:

• Listing: https://www.airbnb.com/rooms/53422981 or https://www.airbnb.com/luxury/listing/53422981 — classified as room, populates listingId.
• Host profile: https://www.airbnb.com/users/show/48213097 — classified as user, populates hostUserId and hostProfileUrl.
• Experience: https://www.airbnb.com/experiences/1234567 — classified as experience, populates experienceId.

Any entry in startUrls that does not contain airbnb.com (case-insensitive) is silently dropped before processing — it never reaches the output and never triggers an error. URLs that don't match any of the three patterns above are still emitted, but classified as airbnbEntityType: "other" with all three ID fields left null. Keyword-mode keywords are plain search terms, not URLs — each one is dropped into the fixed dork template shown above, so "superhost" becomes site:airbnb.com "+44" "superhost" when country is set to the United Kingdom.

📦 Output Format

Every row is typed JSON with a stable field set, pushed to the default dataset. The Actor pushes exactly the same 23 fields the dataset's default view displays — nothing is hidden behind the view. Two structurally different row shapes come out depending on inputMode: a search-mode row (from a Google snippet) and a direct-URL row (identity only, no contact fetch).

Pricing is pay-per-event, single event: row_result. Every row this Actor pushes — from either mode, contact found or not — is charged under the row_result event; the source code has only one push_data call, used uniformly for both search-mode and direct-URL rows, and every call passes charged_event_name="row_result". There is no separate uncharged accounting or error row emitted by this Actor. If you supply neither keywords nor startUrls, the run logs an error and exits before any row is built, so a misconfigured run is never charged.

Output for search-mode rows (Google-derived leads)

{
  "airbnbEntityType": "room",
  "listingId": "53422981",
  "hostUserId": null,
  "experienceId": null,
  "hostProfileUrl": null,
  "title": "Modern 2-Bed Flat, Central London — Property Management",
  "phoneE164": "+442071234567",
  "phoneNational": "2071234567",
  "phoneConfidence": "high",
  "phoneSource": "serp-snippet",
  "allPhoneNumbers": ["+442071234567"],
  "email": "bookings@londonstays.example",
  "allEmails": ["bookings@londonstays.example"],
  "country": "United Kingdom",
  "dialCode": "+44",
  "url": "https://www.airbnb.com/rooms/53422981",
  "description": "Fully managed 2-bedroom apartment near Kings Cross. Contact our property management team at +44 20 7123 4567 or bookings@londonstays.example for long-stay rates.",
  "keyword": "property management",
  "serpRank": 4,
  "serpPage": 1,
  "inputMode": "search",
  "googleQuery": "site:airbnb.com \"+44\" \"property management\"",
  "scrapedAt": "2026-07-26T09:14:02Z"
}

• phoneConfidence is "high" when the snippet carried a genuine +/00 prefix, "medium" in loose mode for a plausible national number, or null when no phone was found.
• phoneSource is always "serp-snippet" when a phone is present, since that is the only source this Actor reads from.
• phoneE164, email, and their all* counterparts are null / [] when no genuine contact was found in the snippet — never a placeholder value.

Output for direct-URL rows (entity identity only)

{
  "airbnbEntityType": "user",
  "listingId": null,
  "hostUserId": "48213097",
  "experienceId": null,
  "hostProfileUrl": "https://www.airbnb.com/users/show/48213097",
  "title": null,
  "phoneE164": null,
  "phoneNational": null,
  "phoneConfidence": null,
  "phoneSource": null,
  "allPhoneNumbers": [],
  "email": null,
  "allEmails": [],
  "country": "United Kingdom",
  "dialCode": "+44",
  "url": "https://www.airbnb.com/users/show/48213097",
  "description": null,
  "keyword": null,
  "serpRank": null,
  "serpPage": null,
  "googleQuery": null,
  "inputMode": "url",
  "scrapedAt": "2026-07-26T09:15:41Z"
}

No page fetch is performed for startUrls — the source code marks listing/host page fetching as a deferred feature — so every contact field on a direct-URL row is null by design. inputMode is the field to filter or branch on when you mix both input types in one run.

Schema stability and export options

The 23-field schema is fixed by the row-building code and does not depend on Airbnb's front-end markup for its keys, so field names stay stable even when Airbnb changes its page layout — only the values extracted from a snippet depend on what Google indexed. Google's own SERP layout is the one dependency: the parser locates result blocks by the div.MjjYud container class, so a Google markup change is the one thing that could require an Actor update, not an Airbnb one. Results are delivered through the standard Apify dataset — export to JSON, CSV, Excel, XML, or RSS from the Apify Console Export button, or read them programmatically with apify_client.

💡 Airbnb Host Contact & Lead Scraper Plus Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run from your CRM or outreach tool whenever a new target keyword or market segment appears — a new city, a new management-company name. Run the Actor with requireContact: true so only rows carrying phoneE164 or email come back, then write hostUserId/listingId, email, phoneE164, and url straight into your CRM's lead record. Because dedupAcrossRuns persists canonical URLs in a key-value store, re-running the same keyword set on new inbound triggers won't re-import leads you already have.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify Schedule to re-run the same keywords list weekly. With dedupAcrossRuns: true, only entities not seen in a prior run come back — the diff is already done for you at the Actor level, so "new rows this run" is the alert list. Watch for new url values carrying a non-null phoneE164 or email as the signal that a previously silent listing has started surfacing contactable details.

🎯 Strategy 3: Bulk dataset build

For a research or outreach dataset spanning many markets, pass one keywords entry per target term (property-management brand names, neighborhood terms, or service phrases) and let maxResultsPerKeyword cap each one; use maxResults as the overall run ceiling. Export the finished dataset to CSV directly from the Apify Console, or pull it with apify_client into your own database. No configurable concurrency parameter exists in this Actor — keywords are processed sequentially within a single run, one Google page fetch at a time.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Inbound lead qualification	Triggered, single run per event	JSON via apify_client
Scheduled monitoring	Tracking new contactable hosts over time	Apify Schedule, recurring	Dataset diff by url
Bulk dataset build	Research or large outreach lists	One run, many keywords	CSV / JSON export

🌴 Related Airbnb Scrapers & Tools

Scraper	What it extracts
Airbnb Scraper — Listings, Fees, Host & Reviews (Scrapio)	Full listing data — pricing, fees, host details, and guest reviews — direct from Airbnb, not Google snippets.
LinkedIn Lead & Contact Finder (Google SERP) (Scraper Engine)	The same Google-dork lead-finding approach applied to LinkedIn profiles instead of Airbnb entities.
Website Contact & Email Crawler (Scrapio)	Crawls a company website for additional contact emails — pair it with a host's own site once you have one.

How to integrate Airbnb Host Contact & Lead Scraper Plus with your stack

Airbnb Host Contact & Lead Scraper Plus works with any language or tool that can make an HTTP request, through the Apify API and the official Apify SDKs.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "keywords": ["property management", "superhost"],
    "country": "United Kingdom (+44)",
    "maxResultsPerKeyword": 20,
    "requireContact": True,
    "phoneCountryStrict": True,
    "dedupAcrossRuns": True,
}

run = client.actor("airbnb-host-contact-lead-scraper-plus").call(run_input=run_input)

leads = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    leads.append(item)

import csv
with open("airbnb_leads.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=leads[0].keys())
    writer.writeheader()
    writer.writerows(leads)

print(f"Exported {len(leads)} rows to airbnb_leads.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const input = {
    keywords: ['property management', 'superhost'],
    country: 'United Kingdom (+44)',
    requireContact: true,
    dedupAcrossRuns: true,
};

const run = await client.actor('airbnb-host-contact-lead-scraper-plus').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Fetched ${items.length} leads`);

Async and scheduled pipelines

For fire-and-forget large keyword lists, start the run with client.actor(...).start(run_input=run_input) instead of .call(), then poll the run status with client.run(run_id).wait_for_finish() or check back later — this Actor has no webhook-delivery feature of its own, but Apify's platform-level webhooks (configurable per Actor in the Apify Console, outside this Actor's own input schema) can notify your system when a run finishes. For recurring jobs, use an Apify Schedule against the same keywords input and let dedupAcrossRuns handle the incremental diff.

🎯 Who Needs Airbnb Host Contact & Lead Scraper Plus? (Use Cases & Industries)

🏢 Property management software vendors and agencies

Sales teams selling channel-management or co-hosting software target professional hosts by running keywords tied to management language, filtering to requireContact: true, and importing hostUserId, phoneE164, and email directly into an outbound sequence.

📊 Lead-generation and directory product builders

Teams building a directory or enrichment API for the short-term-rental industry key records off listingId/hostUserId and refresh on a schedule, relying on dedupAcrossRuns to keep the dataset incremental rather than re-scraping from scratch.

📱 Market and competitive intelligence analysts

Analysts tracking a management brand's or a neighborhood's footprint on Airbnb's indexed search surface watch serpRank, serpPage, and newly appearing url values across scheduled runs of the same keywords.

🔬 Researchers

Academic and market researchers studying professional-host contactability or platform intermediation use airbnbEntityType, allPhoneNumbers, and allEmails against publicly indexed data only — no login, no private data, no page fetch beyond what Google already surfaced.

Is it legal to scrape Airbnb?

Scraping publicly accessible web data is generally lawful in the United States. In hiQ Labs v. LinkedIn Corp (9th U.S. Circuit Court of Appeals, 2019, reaffirmed on remand in 2022), the Ninth Circuit held that scraping data a website makes publicly accessible does not violate the Computer Fraud and Abuse Act. That case concerned access, not Airbnb's own contract terms with its users — separately, scraping in a way that breaches Airbnb's or Google's Terms of Service can expose you to a civil breach-of-contract claim, not a criminal one, and Airbnb's Terms of Service govern what you may do with its site regardless of the CFAA analysis. Because this Actor can return real personal contact details — a host's phone number or email address, when one genuinely appears in a public snippet — data protection law (GDPR in the EU/UK, CCPA in California) may apply to what you do with that data once collected, particularly if the host is an individual rather than a registered business. Airbnb Host Contact & Lead Scraper Plus returns only publicly accessible data surfaced by Google's own index. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Airbnb Host Contact & Lead Scraper Plus work without an Airbnb account?

Yes. The source code contains no Airbnb login or session step — it queries Google directly for keyword mode, and only reads URL structure (no page fetch) for direct-URL mode. No Airbnb credentials are required in either mode.

How does it handle Google's anti-scraping measures?

Every Google request rotates a user-agent and Accept-Language pair from a fixed pool, always routes through Apify's GOOGLE_SERP proxy group, and waits 1–2 seconds (randomized) before each request. Responses are checked for a genuine block or consent page — the parser looks for the MjjYud result-container class first; only when that marker is absent does it fall back to checking for known block strings like "our systems have detected unusual traffic" or a /sorry/index redirect. On a detected block or a network error, the Actor retries up to 3 times per page, rotating to a fresh proxy URL between attempts and sleeping 3–6 seconds between retries.

Can I run it at scale without getting blocked?

The Actor gives up on a keyword's pagination after 3 consecutive empty or failed pages rather than looping indefinitely, and moves on to the next keyword or finishes the run. There is no documented uptime or success-rate figure for Google SERP scraping at scale — how much Google throttles a given proxy pool over a large run is not something the Actor's own code can guarantee.

How fresh is the data it returns?

Every run performs a live Google search or a live URL parse — nothing is cached between runs except the set of previously-seen canonical URLs used for deduplication. Every row carries scrapedAt, an ISO-8601 UTC timestamp set at the moment that row was pushed.

Which fields work best for AI training and RAG indexing?

For RAG, description is the high-information free-text field — it carries the actual search-snippet content Google indexed. For training data, airbnbEntityType, phoneConfidence, and inputMode are the most consistently structured fields, since each is one of a small fixed set of string values on every row. All fields return as typed JSON primitives (strings, numbers, booleans, arrays, or null) — no HTML or nested markup to strip before use.

Does personal data protection law apply to this data?

It can. When a row carries a genuine phoneE164 or email belonging to an individual host rather than a registered business, that is personal data under GDPR and CCPA. The Actor returns only what was already publicly accessible in a Google-indexed snippet; the lawful basis for storing and using that data for your specific purpose sits with you, not with the Actor.

Does it work with Claude, ChatGPT, and other AI agent tools?

There is no MCP server for this Actor. Any agent framework that can call the Apify API — directly, or via apify_client — can start a run and read back typed JSON results; no HTML parsing step is needed before passing a row into an LLM context window.

How does it compare to other Airbnb contact scrapers?

The scrapyspider Airbnb Host Contact Details Scraper fetches the full host profile page and offers optional OpenAI-assisted parsing for structured business details — ratings, review counts, Superhost status, and registration numbers this Actor does not return, as observed on the Apify Store on 2026-07-26. Airbnb Host Contact & Lead Scraper Plus instead covers three entity types (listing, host, and experience) from Google search alone, with an explicit no-fabrication phone-extraction design and built-in cross-run deduplication. The meticulous_snail Airbnb Host Lead Scraper listing had no published README content as of 2026-07-26, so no feature comparison could be made against it.

ℹ️ Disclaimer

Airbnb Host Contact & Lead Scraper Plus extracts only publicly available data surfaced by Google's search index for site:airbnb.com queries, or parsed from the structure of an Airbnb URL you supply directly. This tool is intended for lawful use cases only. Users are responsible for complying with Airbnb's and Google's terms of service, and applicable data protection laws in their jurisdiction, when collecting and using any contact data this Actor returns.