# Recreation.gov Scraper \[$5/1K💰] | Campsites | Availability (`ahmed_jasarevic/recreation-scraper`) Actor

Scrape recreation.gov campgrounds and campsites with nightly fees, amenities, occupancy limits and month-by-month availability calendars. Power campsite alerts, trip planners and camping research.

- **URL**: https://apify.com/ahmed_jasarevic/recreation-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.80 / 1,000 results

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

## Recreation Scraper

Scrape recreation.gov campgrounds and campsites — nightly fees, amenities, occupancy limits and month-by-month availability calendars — for national parks, forests, BLM land and Army Corps facilities across the United States.

### Power Campsite Alerts, Trip Planners And Camping Market Research

- Power campsite-alert services with real available / reserved / closed calendars
- Build trip-planning and van-life apps on federal campground inventory
- Compare nightly fees, hookups and rig limits across parks and states
- Monitor cancellations and released sites for high-demand campgrounds
- Build a camping market dataset for travel research or resale

### How It Works

![How the Recreation Scraper turns a park, state or campground ID into a dataset of campsites with fees, amenities and monthly availability.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-recreation-scraper.webp)

The Actor collects publicly available recreation.gov campground, campsite and permit data and normalizes it into one schema. Provide a search term, state or campground ID; it reads the published facility pages and availability calendars, then writes one row per campsite or permit division.

- `searchQuery`, `state` or `campgroundIds` starts the run.
- `includeAvailability` adds month-by-month available, reserved and closed dates.
- `entityType` selects campgrounds, permits or both.

Each row is one campsite (or one permit division in permit mode) with park, agency, location, site type, occupancy, rig limits, amenities, fee range, rate seasons, availability dates and booking links. Export as JSON, CSV or Excel, or read it through the Apify API.

### Scrape recreation.gov Campsites And Nightly Fees

Discovery accepts three input styles, and at least one is required:

- `searchQuery` — a keyword such as `Acadia`, `Yosemite` or `beach camping`
- `state` — a two-letter code (`CA`) or full name (`California`)
- `campgroundIds` — facility IDs such as `232508` or full recreation.gov URLs; this skips discovery entirely

`entityType` selects what to scrape: `campground` (default), `permit` for wilderness permits and entry-quota availability, or `both`. `maxCampgrounds` defaults to 10 and caps at 500; `maxCampsitesPerCampground` defaults to 300 and caps at 2,000.

### Track Campsite Availability Calendars

`includeAvailability` is on by default. `monthsAhead` controls how many calendar months are fetched, from 1 to 12, starting with the current month.

- `availableDates` — days the site can be booked
- `reservedDates` — days already booked
- `closedDates` — days that are **not bookable**: seasonal closure, outside the reservation window, or not yet released. recreation.gov does not distinguish these cases in its published calendar.
- `quotaAvailability` — permit mode only: per division and quota type, remaining and total quota per day

Availability is fetched once per campground per month and then mapped onto every site, so a 1,000-campsite run stays cheap.

### Input

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `campgroundIds` | array of strings | No | — | Facility IDs (`232508`) or recreation.gov URLs. Skips discovery. |
| `searchQuery` | string | No | — | Keyword discovery, e.g. `Acadia`, `Yosemite`, `beach camping`. |
| `state` | string | No | — | Two-letter code (`CA`) or full name (`California`). |
| `entityType` | string | No | `campground` | `campground`, `permit` or `both`. |
| `includeAvailability` | boolean | No | `true` | Fetch day-by-day calendars for every campsite. |
| `monthsAhead` | integer | No | `1` | Calendar months to fetch, starting with the current month. 1–12. |
| `maxCampgrounds` | integer | No | `10` | Maximum campgrounds (or permits) per run. 1–500. |
| `maxCampsitesPerCampground` | integer | No | `300` | Cap on campsites returned per campground. 1–2,000. |
| `proxy` | object | No | — | Standard Apify proxy configuration. Off by default. |

At least one of `campgroundIds`, `searchQuery` or `state` must be provided.

### Output

One row per campsite, or one row per permit division in permit mode.

| Field | Description |
| --- | --- |
| `recordType` | `campsite` or permit division record. |
| `campgroundId`, `campgroundName` | recreation.gov facility ID and name. |
| `park` | Parent recreation area or park, e.g. `Acadia National Park`. |
| `agency` | Managing agency, e.g. National Park Service or USDA Forest Service. |
| `state`, `city`, `latitude`, `longitude` | Location of the campground or site. |
| `campsiteId`, `siteNumber`, `loop` | Site identity and loop. |
| `siteType`, `siteTypeCategory` | Raw type (`TENT ONLY NONELECTRIC`) and normalized category (Tent / RV / Cabin / Group / Standard). |
| `maxOccupancy`, `minOccupancy`, `maxVehicles` | Occupancy limits. |
| `maxVehicleLengthFt`, `permittedEquipment` | Rig length per equipment type. |
| `amenities`, `attributes` | Site amenities and the full attribute map. |
| `nightlyFee` | `min`, `max`, `currency`, `perUnit` from the published price range. |
| `rateSeasons` | Season types and date ranges attached to the rate table. |
| `availability` | Per month: `availableDates`, `reservedDates`, `closedDates` plus counts. |
| `quotaAvailability` | Permit mode: per-division, per-quota-type remaining and total quota per day. |
| `bookingUrl`, `campgroundUrl` | Direct recreation.gov links. |

### Example Input

```json
{
  "searchQuery": "Acadia",
  "state": "ME",
  "includeAvailability": true,
  "monthsAhead": 2,
  "maxCampgrounds": 3,
  "maxCampsitesPerCampground": 50
}
```

### Example Output

```json
{
  "recordType": "campsite",
  "campgroundId": "272299",
  "campgroundName": "Cottonwood Campground",
  "park": "Joshua Tree National Park",
  "agency": "National Park Service",
  "state": "CA",
  "city": "Indio",
  "latitude": 33.75,
  "longitude": -115.825,
  "campsiteId": "103759",
  "siteNumber": "B27",
  "siteType": "STANDARD NONELECTRIC",
  "siteTypeCategory": "Standard",
  "maxOccupancy": 6,
  "maxVehicles": 2,
  "maxVehicleLengthFt": 45,
  "amenities": ["Picnic Table", "Fire Ring", "BBQ"],
  "nightlyFee": { "min": 35, "max": 35, "currency": "USD", "perUnit": "night" },
  "availability": {
    "2026-11": {
      "availableCount": 6,
      "reservedCount": 24,
      "closedCount": 0
    }
  },
  "bookingUrl": "https://www.recreation.gov/camping/campsites/103759",
  "campgroundUrl": "https://www.recreation.gov/camping/campgrounds/272299"
}
```

### Schedule Campsite Monitoring And Integrations

- **Cancellation alerts** — run hourly or daily for a shortlist of campground IDs and diff `availableDates` between runs.
- **Season opening** — run monthly with `monthsAhead: 12` to catch newly released inventory.
- **Webhooks** — send new availability to Slack, email, a dashboard or a booking workflow through the Apify API, webhooks, Zapier or Make.
- **Scheduling** — availability changes constantly in peak season; a scheduled run is more useful than a one-off export.

### Related Actors

- [Recreation.gov Scraper](https://apify.com/lexis-solutions/recreation-gov-scraper) — campgrounds, permits, timed entry and facilities.
- [Recreation.gov Campsite Availability Scraper](https://apify.com/lulzasaur/recreation-gov-scraper) — availability by location and dates.
- [Recreation.gov Campground Scraper (Campsites & Amenities)](https://apify.com/steadfetch/recreation-gov-campground-extractor) — campground records and campsite inventory.
- [Recreation.gov Permit & Campsite Live Tracker](https://apify.com/hikemetrics/recreation-gov-permit-tracker) — permit and facility availability checks.
- [The Dyrt Scraper - Campground Reviews & Prices](https://apify.com/lulzasaur/thedyrt-scraper) — campground reviews and prices beyond federal land.

### FAQ

#### Why use this Actor instead of the official recreation.gov API?

The official RIDB API is keyed, rate-limited and focused on facility reference data; it does not return the live day-by-day campsite calendar shown on recreation.gov. This Actor collects the public campground and availability data that the site shows to any visitor, normalizes the statuses and maps the calendar onto every campsite in one run.

#### What are the alternatives to this Actor?

`lexis-solutions/recreation-gov-scraper` covers listings and facilities, `lulzasaur/recreation-gov-scraper` focuses on availability by date, `hikemetrics/recreation-gov-permit-tracker` targets permits, and `steadfetch/recreation-gov-campground-extractor` returns campground records. This Actor combines campsite inventory, fees and multi-month calendars in one dataset.

#### What does `closedDates` mean?

A closed day is not bookable. It can be a seasonal closure, a date outside the reservation window, or inventory that has not been released yet. recreation.gov does not distinguish those cases in its published calendar, so the Actor reports them all as closed rather than guessing.

#### Can I scrape permits and timed entry?

Yes. Set `entityType` to `permit` or `both`. Permit mode returns one record per division with `quotaAvailability`: remaining and total quota per quota type per day.

#### Why do some campsites show every day as closed?

Seasonal campgrounds and sites that are not yet released come back with the whole month closed. That is the source's real state, not an error.

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

No. The public pages used here require no account, cookie or CAPTCHA. A proxy is optional and only useful if you run very high volume from one IP.

### For AI Agents & LLM Apps

Returns recreation.gov campsites with fees, amenities and monthly availability calendars as one row per campsite.

Minimal input:

```json
{ "searchQuery": "Acadia", "state": "ME", "maxCampgrounds": 1 }
```

Direct facility lookup:

```json
{ "campgroundIds": ["232508"], "monthsAhead": 2 }
```

Permit availability:

```json
{ "searchQuery": "Half Dome", "entityType": "permit", "monthsAhead": 2 }
```

Output fields: `recordType`, `campgroundId`, `campgroundName`, `park`, `agency`, `state`, `city`, `latitude`, `longitude`, `campsiteId`, `siteNumber`, `loop`, `siteType`, `siteTypeCategory`, `maxOccupancy`, `minOccupancy`, `maxVehicles`, `maxVehicleLengthFt`, `permittedEquipment`, `amenities`, `attributes`, `nightlyFee`, `rateSeasons`, `availability`, `quotaAvailability`, `bookingUrl`, `campgroundUrl`.

Behaviors an agent should know:

- At least one of `campgroundIds`, `searchQuery` or `state` must be set; otherwise the run has nothing to discover.
- `campgroundIds` skips search entirely and is the most predictable mode.
- `includeAvailability: false` returns inventory and fees without calendars and is much cheaper.
- `closedDates` includes seasonal closures, dates outside the booking window and unreleased inventory.
- `maxCampsitesPerCampground` caps rows per campground, not per run.
- Billing: $0.005 per campsite record plus the one-time Actor start event; free users receive the first 10 records.

### Legal & Compliance Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by recreation.gov, the National Park Service, the USDA Forest Service, the Bureau of Land Management or the US Army Corps of Engineers. It collects only publicly visible recreation.gov pages and availability data and does not log in, hold a reservation, bypass a CAPTCHA or modify any booking. The data describes public federal facilities and does not contain personal information. You are responsible for complying with recreation.gov's Terms of Use and with applicable law when you republish or commercialize the data.

### SEO Keywords

recreation.gov scraper, campsite availability api, recreation.gov campsites, campground availability data, campsite alert data, national park campgrounds, recreation.gov api, campsite fees, campground dataset, camping market research, rv campground data, tent campsite data, recreation.gov permits, timed entry availability, campsite booking data, federal campgrounds, campsite monitoring, campground scraper, recreation.gov campground ids

# Actor input Schema

## `campgroundIds` (type: `array`):

Direct recreation.gov facility IDs (e.g. 232508) or URLs (https://www.recreation.gov/camping/campgrounds/232508). When provided, discovery via search is skipped.

## `searchQuery` (type: `string`):

Keyword used to discover campgrounds on recreation.gov, e.g. "Acadia", "Yosemite", "beach camping".

## `state` (type: `string`):

Filter by US state. Accepts a two-letter code (CA) or full name (California).

## `entityType` (type: `string`):

Campgrounds/campsites, permits and entry-quota (timed entry) availability, or both.

## `includeAvailability` (type: `boolean`):

Fetch the day-by-day available / reserved / closed calendar for every campsite.

## `monthsAhead` (type: `integer`):

How many calendar months of availability to fetch, starting with the current month (1-12).

## `maxCampgrounds` (type: `integer`):

Maximum number of campgrounds (or permits) to process per run.

## `maxCampsitesPerCampground` (type: `integer`):

Cap on campsites returned per campground.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "campgroundIds": [],
  "searchQuery": "Acadia",
  "entityType": "campground",
  "includeAvailability": true,
  "monthsAhead": 1,
  "maxCampgrounds": 10,
  "maxCampsitesPerCampground": 300,
  "proxy": {
    "useApifyProxy": 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 = {
    "campgroundIds": [],
    "searchQuery": "Acadia",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/recreation-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 = {
    "campgroundIds": [],
    "searchQuery": "Acadia",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/recreation-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 '{
  "campgroundIds": [],
  "searchQuery": "Acadia",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/recreation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/recreation-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/wJQGbnxrn9dQLTJQg/builds/FqCEs2yWhQcQ2dVcB/openapi.json