Airbnb Reviews Scraper

Scrape Airbnb reviews from public room URLs and export ratings, review text, dates, reviewer details, host replies, and listing context to CSV, JSON, or Excel. This Airbnb reviews API alternative collects pages beyond the initial listing preview and lets you choose review order, a date cutoff, a language and region, and per-listing limits.

Each dataset item represents one public review. Supply one or several room URLs, run the scraper, and use the resulting flat records for analysis, monitoring, or reporting. The scraper reads the listing page to identify the current public review request, then paginates the review data. A tested room with 496 reported reviews returned records beyond offset 400; a 100-review run completed successfully.

What data can you extract from Airbnb?

The dataset uses stable camelCase field names. Fields that Airbnb does not provide for a particular review are null, except reviewPhotoUrls, which is an empty array when no photo URLs are present. The original review language and text remain available alongside localized fields, so analysis can distinguish what the guest wrote from what was returned for the selected locale.

Field	Description	Example
startUrl	Canonical room URL associated with the review	https://www.airbnb.com/rooms/12937
listingId	Numeric room identifier as a string	12937
listingReviewCount	Total public review count reported for the room	496
id	Unique review identifier	1780419577076084622
language	Original review language code	en
text	Original review body	It took me a while to fall asleep...
localizedText	Text returned in the requested locale when available	It took me a while to fall asleep...
localizedReview	Legacy localized text field, when supplied	null
createdAt	Review timestamp in ISO format	2026-09-22T12:15:52Z
reviewHighlight	Short context displayed with the review	Stayed a few nights
highlightType	Category of that context	LENGTH_OF_STAY
rating	Review star rating	5
ratingAccessibilityLabel	Human-readable rating label	Rating, 5 stars
response	Public reply from the reviewed host, if one exists	null
reviewerLocation	Location displayed with the review	Berkeley, California
reviewPhotoUrls	URLs of public photos attached to the review	[]
reviewerId	Reviewer account identifier	7987311
reviewerName	Public reviewer display name	Present in full dataset
reviewerPictureUrl	Public reviewer profile image URL	Image URL or null
reviewerProfileUrl	Public reviewer profile link	Profile URL or null
revieweeId	Reviewed host account identifier	50124
revieweeName	Public reviewed host display name	Present in full dataset
revieweePictureUrl	Public host profile image URL	Image URL or null
revieweeProfileUrl	Public host profile link	Profile URL or null

id identifies the review, while listingId identifies the room. Keep both when combining runs: the same room can appear in several runs, but a review should be counted once per room. The total in listingReviewCount is context from Airbnb, not a guarantee that a limited run exported that many rows. For example, a room can report 496 reviews while an input cap exports only 100.

The output intentionally separates reviewer and reviewed-host details into columns. That makes common operations such as grouping by room, counting ratings, and filtering for replies possible without unpacking nested user objects. A missing response does not mean the review failed to load; it means no public response was present in the returned record.

How to scrape Airbnb reviews

1. Copy the public URL of each room you want to inspect. A URL such as https://www.airbnb.com/rooms/12937 is sufficient; the review subpage form is also accepted.
2. Add those URLs to Room URLs. Set Maximum reviews per listing if you only need a sample from each room, or leave it empty to page through the available reviews.
3. Choose a sort order. Use Most recent with Reviews since date when you are collecting only new reviews after a previous run.
4. Start the run. The scraper fetches each listing, requests review pages, and writes one item per review to the dataset.
5. Open the dataset and download JSON, CSV, or Excel. For a recurring process, schedule the same input and compare review IDs between runs.

The scraper accepts multiple URLs in one run. It removes duplicate room IDs from the input before scraping, and its total limit stops the entire run once enough items have been written. If a room URL is invalid or unavailable, the run logs that failure and continues with the other rooms. A run where every room fails ends with an error rather than reporting a misleading successful empty dataset.

Input

Name	Type	Default	Description
startUrls	Array of room URL objects	Example room URL	Required. Each entry contains a url for a public Airbnb room.
maxReviewsPerListing	Integer	Empty	Maximum items from each room. Empty means page until the available reviews end.
maxItems	Integer	0	Maximum items across all rooms. Zero means no total cap.
sortBy	String	most-recent	most-recent, most-relevant, highest-rated, or lowest-rated.
sinceDate	Date string	Empty	Include reviews on or after YYYY-MM-DD. Requires most-recent sorting.
locale	String	en-US	Requested language and region for localized fields, such as de-DE.
proxyConfiguration	Object	Enabled	Proxy settings used for listing and review requests.

A realistic input for a first run is:

{
  "startUrls": [
    { "url": "https://www.airbnb.com/rooms/12937" }
  ],
  "maxReviewsPerListing": 100,
  "maxItems": 100,
  "sortBy": "most-recent",
  "locale": "en-US"
}

The per-listing cap and total cap serve different purposes. If you provide five rooms, maxReviewsPerListing: 100 allows up to 100 reviews from each one. Adding maxItems: 250 stops the entire run at 250 reviews, even if some rooms still have more. The earliest rooms in the input are processed first, so order the URLs deliberately when the total cap is smaller than the sum of the per-listing caps.

For incremental monitoring, set sortBy to most-recent and enter the previous collection date as sinceDate. The cutoff includes reviews created on that date. The scraper stops reading a room when it reaches an older review, which avoids paging through years of records when only recent changes matter. A cutoff cannot be combined with another sort order because older reviews may appear before newer ones in those orders.

Output example

This excerpt comes from a successful 100-review run of the sample room. Long review text and public profile fields are omitted from the excerpt; the actual dataset item includes every field in the table above.

{
  "startUrl": "https://www.airbnb.com/rooms/12937",
  "listingId": "12937",
  "listingReviewCount": 496,
  "id": "1780419577076084622",
  "language": "en",
  "text": "It took me a while to fall asleep to the sound of the subway — but there were also crickets all night long, in early autumn.",
  "createdAt": "2026-09-22T12:15:52Z",
  "reviewHighlight": "Stayed a few nights",
  "highlightType": "LENGTH_OF_STAY",
  "rating": 5,
  "ratingAccessibilityLabel": "Rating, 5 stars",
  "response": null,
  "reviewPhotoUrls": []
}

The text above is shortened for readability. The dataset preserves the full text returned for each review. Timestamps use the source's ISO timestamp, which can be converted into reporting periods or compared directly with a date cutoff. The rating is a numeric value suitable for aggregation; the accessibility label is the source's display wording.

Use cases

• Property quality monitoring: Collect recent reviews for a portfolio of rooms, then group comments by room and month. Compare rating distributions and read the actual text behind a change in average rating.
• Host response audits: Filter records where response is present to see which public reviews received a reply. Use createdAt and the room URL to review the surrounding context.
• Travel research: Compare publicly visible guest feedback on cleanliness, location, sleep quality, and communication across several candidate rooms. The review text gives detail that a headline rating alone cannot convey.
• Hospitality research: Build a sample of reviews from rooms in a chosen set and analyze themes across time. Preserve listingId and id so repeated runs can be deduplicated.
• Recent-review alerts: Schedule a most-recent run with a cutoff date, then notify an internal team when new review IDs appear. A modest per-listing limit keeps recurring checks bounded.
• Localization checks: Request a chosen locale while retaining language and text. This helps distinguish original-language reviews from localized text returned by the site.

Use public review data with care. Display names, profile links, images, and locations can refer to people. Collect only fields needed for a legitimate purpose and apply appropriate retention and access controls to exported datasets.

How much does it cost to scrape Airbnb?

The configured event price is $0.001 per delivered review, or $1 per 1,000 reviews. Charges are based on items written to the dataset, so a smaller limit produces a smaller event charge. Platform usage is included in this per-result price. The number of public reviews shown on a listing is not itself billed; only delivered records count.

Delivered reviews	Event cost
100	$0.10
1,000	$1.00
5,000	$5.00
10,000	$10.00

For example, checking ten rooms and exporting 100 reviews from each produces at most 1,000 results, so the event charge is at most $1. A daily check that yields 20 new results for 30 days produces 600 results and an event charge of $0.60, assuming each review is delivered once. Repeatedly exporting the same reviews in separate runs counts those items again. Keep your own list of review IDs if you need to avoid repeated downstream processing.

A room may have fewer reviews than the requested cap. If it has 37 public reviews and the cap is 100, the dataset can contain only the 37 available records from that room, and the result charge follows the actual count. You can also set a global maxItems value to bound the maximum event cost of a multi-room run.

Tips for best results

Use the direct room URL, including its numeric room ID. Search result links, host profile links, and URLs from unrelated domains are not valid inputs. The scraper accepts an optional /reviews suffix but normalizes the output to the canonical room URL, making it easier to join records from repeated runs.

Start with a cap of 50 or 100 reviews when evaluating a set of rooms. Once the output fields and coverage fit your workflow, leave the per-listing cap empty to collect all available pages. The review endpoint returned 50 records when requested for 100 in testing, so the scraper uses 50-record pages. It advances the offset after each page and stops at the reported total or when no more records are returned.

Choose the sort order for the question you are answering. Most recent is suited to monitoring and date cutoffs. Highest rated and Lowest rated surface opposite ends of the rating distribution. Most relevant follows the site's relevance order; it is useful for browsing but should not be interpreted as chronological. The sorting options are passed to the same public review query used for listing reviews.

Use locale when display language matters. The language field identifies the review's original language, while localized fields reflect what the source returned for the requested locale. The site does not guarantee a translation for every item. If you need a single comparable corpus, inspect both the original and localized columns before treating them as interchangeable.

For recurring checks, use a date cutoff and save review IDs from prior runs. The cutoff reduces requests when only recent reviews matter, while the IDs let you deduplicate any overlap around the boundary date. A review created late on the cutoff date is included because the comparison uses the review's calendar date.

Limits

Only publicly accessible room reviews are supported. An unavailable room or a page requiring a sign-in can prevent collection for that URL. The scraper does not access private messages, booking details, unpublished reviews, or information visible only to an account holder.

The source can omit individual fields. Public host responses are absent on many reviews, so response is often null. Photo URLs are empty on reviews without attached photos. The legacy localizedReview field may be null even when localizedText is filled. A reported listing review count describes the source at request time and may change after the run.

Testing reached a room's final page at offset 480, returning the last 16 of 496 reviews. This confirms pagination beyond a short preview for that room; it does not promise the same coverage for every room. The site's review query, its operation identifier, or the listing page's public configuration can change. If the source changes, a run may fail until the scraper is updated.

The site returned some nonfatal errors for review-tag summary fields while still returning complete review records. The scraper uses the review records when present and does not expose those summary fields. If the review records themselves are missing, it reports a failure rather than substituting partial listing metadata for reviews.

Automated workflows

The same input can be reused in a scheduled run or sent through a programmatic call. A monitoring workflow can supply a set of room URLs, sortBy: "most-recent", and a recent sinceDate, then consume the dataset after the run. A comparison workflow can submit several rooms with maxReviewsPerListing: 100, group the resulting records by listingId, and calculate rating or response statistics.

When automating repeated collections, keep the input stable and save both listingId and id from each item. Those two fields are sufficient to identify the room and review in a downstream table. Add createdAt when you need time windows, and retain startUrl when analysts need a link back to the room. If the same room appears twice in an input list, it is collected only once in that run.

FAQ

Is it legal to collect Airbnb reviews?

The scraper collects public pages and review data. Whether a particular use is permitted depends on the site's terms and applicable law. Respect privacy rules, including GDPR where relevant, and avoid collecting or using personal data without a legitimate basis. Consult qualified counsel for decisions about your specific use.

Do I need to provide a proxy?

The default proxy setting is ready for a standard run. You can override it if your account and workflow require different routing. The scraper starts with a lower-cost route and can escalate on an access block. A successful test of the sample room did not encounter a block.

How fast is a run?

The sample run delivered 100 reviews in one successful remote run. Actual time depends on how many rooms and pages you request, source response time, and any access retries. A limit of 100 needs fewer review requests than a full historical collection from a room with hundreds of reviews.

Can I schedule and monitor it?

Yes. Save the input as a recurring task or schedule a run at the interval you need. Compare review IDs with a prior dataset, or use a recent cutoff date to reduce historical paging. Check the run status and logs if a room becomes unavailable.

Can I export to a spreadsheet?

Yes. Download the dataset as CSV or Excel for spreadsheet analysis, or as JSON for a data pipeline. The output fields are flat, so ratings, dates, room IDs, and public replies become ordinary columns.

Why is a field empty?

The source may not provide it for that review. For example, a review without a public host reply has response: null, and a review without photos has reviewPhotoUrls: []. The original text and key identity fields were filled in the 100-review test; optional fields vary by item.

Can it collect every review from a room?

Leave the per-listing cap empty and do not set a restrictive total cap. The scraper pages until the source returns fewer records than requested, no records, or the reported total is reached. A tested room was accessible through its final page, but availability and source behavior can vary.

Integrations

Use the dataset through the platform's API, scheduled runs, or webhooks. Export files to a spreadsheet, send new review records to an internal database, or trigger a notification when a new review ID appears. The room and review identifiers make it straightforward to join results across runs and prevent duplicate downstream records.

Support

Open an issue on the Issues tab; we reply within 24h and add fields on request.