# Hipcamp Scraper - Campgrounds, RV Parks & Glamping (`abotapi/hipcamp-camping-glamping-scraper`) Actor

Scrape Hipcamp campgrounds, RV parks, glamping and unique stays by US or AU region or listing link: price per night, rating, reviews, host, amenities, sites, photos, coordinates. Incremental monitoring, resume, MCP export.

- **URL**: https://apify.com/abotapi/hipcamp-camping-glamping-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 listing records

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Hipcamp Scraper - Campgrounds, RV Parks & Glamping

Scrape Hipcamp (hipcamp.com), the camping and glamping marketplace ("Airbnb
for camping"), across every US state and Australian state or territory.
The actor returns campgrounds, RV parks, glamping sites and unique stays
with price per night, rating signal, host details, amenities, sites,
photos and coordinates. It also monitors listings across runs (NEW,
UPDATED, REAPPEARED, EXPIRED), resumes interrupted pulls, and pipes results
into your apps through MCP connectors.

### Why This Scraper?

- Real marketplace data: price per night, recommend percentage and counts,
  booking and favorites counts, campsites, land category, accommodation
  types and photos in one record.
- Full-detail reads on demand: host name and avatar, response rate,
  street address, description, core/basic/RV amenities, activities,
  terrain, stay policies and the per-site price list.
- Region search with a deep walk: every region returns its front-page
  highlights first, then continues through the region's whole catalogue
  until your record budget is reached.
- URL mode: paste any listing link for a direct full-detail read.
- Availability monitoring: scheduled runs classify every listing as NEW,
  UPDATED, UNCHANGED, REAPPEARED or EXPIRED, with per-campaign state you
  can name or share.
- MCP connector export: send results to Notion and other connectors
  without changing the dataset.
- Structured failures: a blocked or broken run fails loudly with a clear
  message instead of returning an empty dataset.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example value |
|---|---|
| kind | listing |
| recordId / listingId | 000000 |
| maskedId | xx000000 |
| url | https://example.com/en-US/land/pine-ridge-example-camp-xx000000 |
| title | Pine Ridge Example Camp |
| pricePerNight | 42.0 |
| basePricePerNight | 50.0 |
| currency | USD |
| recommendsPercentage / recommendsCount | 92 / 240 |
| bookingsCount / favoritesCount | 850 / 14 |
| campsitesCount | 4 |
| accommodationTypes | \["tent", "rv"] |
| cityName / stateName / countryCode | Exampleville / California / US |
| latitude / longitude | 38.0 / -120.0 |
| imageUrl | https://example.com/images/... |
| detailLoaded | true |
| hostName / hostJoinedAt | Jane D. / 2026-01-01T00:00:00.000Z |
| coreAmenities / basicAmenities | \["fire", "pets", "toilet", "trash"] / \["picnic-table", "wifi"] |
| terrain / activities | \["river"] / \["fishing", "hiking"] |
| acreage | 12.0 |
| sites | \[{"siteId": "000001", "name": "Example Meadow", "pricePerNight": 42.0, ...}] |
| changeType | NEW |
| firstSeenAt / lastSeenAt | 2026-01-01T00:00:00.000Z |

Front-page tiles carry the tile fields and `detailLoaded: false`; listings
read in full (URL mode, the deep walk, or the detail toggle) add the host,
address, amenities, terrain, activities, policies, per-site price list and
`detailLoaded: true`. Hipcamp's public rating signal is a recommend
percentage plus count (per listing and per site); individual review texts
are not part of the listing surface this actor reads. Every record also
carries the full upstream objects (raw, rawDetail), so no upstream field is
ever dropped.

### How to Use

Zero setup: the source serves its catalogue openly, so paste one or more
regions (for example `california`, `new south wales`, `texas`) and run. No
account is needed. Supported regions: all 50 US states plus Puerto Rico
(`alabama` ... `wyoming`), and all Australian states and territories (`new
south wales`, `victoria`, `queensland`, `western australia`, `south
australia`, `tasmania`, `northern territory`, `australian capital
territory`). Region names accept plain text, slugs, or a region page URL.
For recurring alerting, switch on incremental mode and schedule the run.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | select | search | search (regions) or url (listing links) |
| regions | list | `california` | Region names, slugs or region page URLs (search mode) |
| listingInputs | array | empty | Listing links or /en-US/land/... paths (url mode) |
| urls | array | empty | Alias for listingInputs, accepted under the usual Apify URL-mode name |
| fetchDetails | boolean | false | Also read full detail for front-page tiles (adds the Detail enrichment event per read) |
| maxItems | integer | 20 | Stop after this many records (0 = no limit) |
| resumeFromRunId | string | empty | Continue one interrupted run, skipping collected ids |
| incrementalMode | boolean | false | Recurring monitoring with change detection |
| stateKey | string | empty | Name a monitoring campaign (incremental mode) |
| emitUnchanged | boolean | false | Also return UNCHANGED rows (returns and bills extra rows) |
| emitExpired | boolean | false | Also return EXPIRED rows after a complete scan |
| mcpConnectors | array | empty | Optional MCP connector export |
| notionParentPageUrl | string | empty | Notion parent page for the Notion connector |
| maxNotifyListings | integer | 50 | Cap per connector per run |
| proxyConfiguration | object | proxy on | Standard Apify proxy settings |

Filters apply to search mode only; URL mode reads the listings you name
directly. Cost shape: a region's front page is one request for about 20
tiles; listings beyond it (and every URL-mode read) need one request per
listing, and each of those reads adds one Detail enrichment event. A run
whose detail reads fail systemically stops the deep walk and ships the
front-page tiles instead of grinding through the region.

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "kind": "listing",
  "recordId": "000000",
  "listingId": "000000",
  "maskedId": "xx000000",
  "url": "https://example.com/en-US/land/pine-ridge-example-camp-xx000000",
  "title": "Pine Ridge Example Camp",
  "pricePerNight": 42.0,
  "basePricePerNight": 50.0,
  "currency": "USD",
  "recommendsPercentage": 92,
  "recommendsCount": 240,
  "bookingsCount": 850,
  "campsitesCount": 4,
  "cityName": "Exampleville",
  "stateName": "California",
  "stateAbbrvName": "CA",
  "countryCode": "US",
  "latitude": 38.0,
  "longitude": -120.0,
  "detailLoaded": true,
  "hostName": "Jane D.",
  "coreAmenities": ["fire", "pets", "toilet", "trash"],
  "basicAmenities": ["picnic-table", "wifi"],
  "terrain": ["river"],
  "sites": [
    {
      "siteId": "000001",
      "name": "Example Meadow",
      "accommodationType": "tents",
      "pricePerNight": 42.0,
      "capacity": 4,
      "isInstantBookable": true
    }
  ],
  "raw": { "full upstream listing object" },
  "changeType": "NEW",
  "changedFields": [],
  "firstSeenAt": "2026-01-01T00:00:00.000Z",
  "lastSeenAt": "2026-01-01T00:00:00.000Z"
}
```

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model
Context Protocol (MCP) connectors. This is an extra delivery step **after**
the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable
**summary** of each record, not the full JSON. Each item becomes one entry
with a **title** (the listing's name) and its key fields flattened to plain
text (price per night, location, recommends percentage, URL, ...). Nested
objects are collapsed to their main value and long lists are trimmed to the
first few names. The **complete, full-fidelity record always stays in the
Apify dataset**; the connector copy is a readable digest for browsing in
your app.

- **Notion** -> one page per item (title + a summary body), created under
  the page you set in `notionParentPageUrl`.
- **Linear / Airtable / other** -> one record/issue per item with the same
  title + fields.

How to enable:

1. Authorize a connector once under **Apify -> Settings -> API &
   Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field
   (`mcpConnectors`). (If the picker is empty, you haven't authorized a
   connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items
   should be created.
4. Optionally cap each connector's writes per run with
   `maxNotifyListings` (default 50).

The connection is mediated by Apify's MCP proxy, so this actor never sees
your third-party credentials. Leave the field empty to skip: the export only
runs when a connector is selected.

### Plan Requirement and Terms Note

The actor uses the Apify proxy with automatic exit rotation; run it on any
plan that includes proxy access. The source is a public marketplace: the
actor reads the same pages a browser reads, and automated reading may sit
outside the source's terms of use, so keep volumes reasonable and respect
the source's terms.

# Actor input Schema

## `mode` (type: `string`):

Search reads listings across one or more regions (US states, Australian states and territories). URL mode reads the exact listings you name.

## `regions` (type: `array`):

Search mode: one or more regions by name or slug. United States: all 50 states plus Puerto Rico. Australia: all states and territories. Example: california, new south wales, texas, tasmania. See the README for the full list.

## `listingInputs` (type: `array`):

URL mode: Hipcamp listing links (https://www.hipcamp.com/en-US/land/...) or /en-US/land/... paths. Multi-value supported.

## `urls` (type: `array`):

Alias for Listing links, accepted under the name other Apify actors use for URL mode. Each entry is a listing link or path; entries are read in order.

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

Stop after this many records (0 = no limit; the run then stops when the regions' catalogues are exhausted).

## `fetchDetails` (type: `boolean`):

Off by default: front-page tiles already carry price, rating, photos and coordinates. Turn on to also read every front-page listing's detail page (host, amenities, sites, policies). Each read adds one Detail enrichment event.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning listings already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching listing as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED listings. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each search, filter and lookup setup; use State key to name or deliberately share a monitoring campaign.

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

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search and filter settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return listings that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return listings that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which listing pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on listings written to each connector per run. Does not affect the dataset.

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

Apify Proxy settings. Works on every proxy plan; the source is served through connection pools with automatic exit rotation.

## Actor input object example

```json
{
  "mode": "search",
  "regions": [
    "california"
  ],
  "listingInputs": [
    "https://example.com/en-US/land/pine-ridge-example-camp-xx000000"
  ],
  "maxItems": 20,
  "fetchDetails": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "regions": [
        "california"
    ],
    "listingInputs": [
        "https://example.com/en-US/land/pine-ridge-example-camp-xx000000"
    ],
    "maxItems": 20,
    "fetchDetails": false,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/hipcamp-camping-glamping-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "regions": ["california"],
    "listingInputs": ["https://example.com/en-US/land/pine-ridge-example-camp-xx000000"],
    "maxItems": 20,
    "fetchDetails": False,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/hipcamp-camping-glamping-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "regions": [
    "california"
  ],
  "listingInputs": [
    "https://example.com/en-US/land/pine-ridge-example-camp-xx000000"
  ],
  "maxItems": 20,
  "fetchDetails": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/hipcamp-camping-glamping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/hipcamp-camping-glamping-scraper"
        }
    }
}

```

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

## OpenAPI specification

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