# National Park Service Parks Scraper (`parseforge/nps-parks-api-scraper`) Actor

Export U.S. National Park Service data including parks, alerts, campgrounds, events, and fees. Pulls park names, locations, addresses, operating hours, contact info, entrance fees, activities, and topics across 470+ NPS units (national parks, monuments, historic sites, seashores).

- **URL**: https://apify.com/parseforge/nps-parks-api-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 result items

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏞️ National Park Service Parks Scraper

> 🚀 **Export the U.S. National Park Service catalog in seconds.** Pull **470+ parks, monuments, historic sites, seashores, and recreation areas** with hours, fees, activities, alerts, and contacts. No login, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-21 · **📊 22 fields** per park record · **🏞️ 470+ NPS units** · **🇺🇸 56 states & territories** · **5 datasets**

The **National Park Service Parks Scraper** exports the official NPS catalog maintained by the U.S. Department of the Interior. Each park record returns **22 fields**, including park code, designation, states, coordinates, full description, weather and directions info, contact details, entrance fees and passes, operating hours per unit, activities, topics, addresses, and a gallery of representative images.

The catalog covers **every NPS unit**: 63 designated National Parks, plus National Monuments, National Historic Sites, National Seashores, National Recreation Areas, National Battlefields, and more (470+ in total). Coverage spans every U.S. state plus the District of Columbia, Puerto Rico, U.S. Virgin Islands, Guam, American Samoa, and the Northern Mariana Islands.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Travel apps, RV and camping platforms, outdoor brands, trip-planning startups, GIS analysts, journalists | Park directory enrichment, trip-planning autocomplete, fees and hours lookup, alerts and closures monitoring, campground inventory, activity-based filtering |

---

### 📋 What the NPS Parks Scraper does

Five datasets in a single Actor:

- 🏞️ **Parks.** Every NPS unit with full metadata, hours, fees, activities, and images.
- ⚠️ **Alerts.** Active park alerts, closures, and advisories.
- 🏕️ **Campgrounds.** NPS-operated campgrounds with reservation info, amenities, and accessibility.
- 🎫 **Events.** Ranger talks, junior ranger programs, special exhibits, and seasonal events.
- 💲 **Fees & passes.** Entrance fees, vehicle permits, annual passes, and free-day calendars.

Each park record carries identifiers (ID, park code, designation), location (states, latitude, longitude), descriptive text (description, weather, directions), contacts (phone, email), monetary info (entrance fees, passes), operating hours (per unit with standard hours and exceptions), classification (activities, topics), addresses (physical and mailing), and a gallery of titled images.

> 💡 **Why it matters:** NPS data is the backbone of every U.S. travel and outdoor recreation app. Pulling it yourself means handling per-endpoint pagination and joining sparse sub-resources. This Actor returns a clean per-park row with every sub-resource flattened into ready-to-use arrays.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded NPS dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>endpoint</code></td><td>string</td><td><code>"parks"</code></td><td><code>parks</code>, <code>alerts</code>, <code>campgrounds</code>, <code>events</code>, or <code>fees</code>.</td></tr>
<tr><td><code>stateCode</code></td><td>string</td><td><code>""</code></td><td>Two-letter state filter. Empty = all states and territories.</td></tr>
<tr><td><code>parkCode</code></td><td>string</td><td><code>""</code></td><td>Comma-separated park codes (e.g. <code>yose,grca,zion</code>).</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Optional free-text keyword.</td></tr>
<tr><td><code>apiKey</code></td><td>string</td><td><code>""</code></td><td>Optional personal key for higher rate limits.</td></tr>
</tbody>
</table>

**Example: every park in California.**

```json
{
    "maxItems": 100,
    "endpoint": "parks",
    "stateCode": "CA"
}
````

**Example: campgrounds in Yosemite, Grand Canyon, and Zion.**

```json
{
    "maxItems": 50,
    "endpoint": "campgrounds",
    "parkCode": "yose,grca,zion"
}
```

> ⚠️ **Good to Know:** the bundled key works for casual use. For production workloads, request a free personal key from the data service to lift rate limits. Field completeness varies by park unit; flagship parks return rich fees, hours, and image data, while smaller units may carry empty arrays for those fields.

***

### 📊 Output

Each park record contains **22 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"77E0D7F0-1942-494A-ACE2-9004D2BDC59E"` |
| 🏞️ `name` | string | `"Abraham Lincoln Birthplace National Historical Park"` |
| 🏷️ `parkCode` | string | `"abli"` |
| 🏛️ `designation` | string | `"National Historical Park"` |
| 🇺🇸 `states` | string | `"KY"` |
| 🔗 `url` | string | `"https://www.nps.gov/abli/index.htm"` |
| 📍 `latitude` | number | `37.5858662` |
| 📍 `longitude` | number | `-85.67330523` |
| 📄 `description` | string | full park description |
| ⛅ `weatherInfo` | string | seasonal climate notes |
| 🧭 `directionsInfo` | string | how to get there |
| ☎️ `phone` | string | `"2703583137"` |
| 📧 `email` | string | `"ABLI_Administration@nps.gov"` |
| 💲 `entranceFees` | array | per-fee objects |
| 🎫 `entrancePasses` | array | annual and lifetime passes |
| 🕒 `operatingHours` | array | per-unit standard hours and exceptions |
| 🎯 `activities` | array | `["Hiking","Stargazing","Picnicking",...]` |
| 🏷️ `topics` | array | `["Presidents","Geology","Night Sky",...]` |
| 🏢 `addresses` | array | physical and mailing addresses |
| 🖼️ `images` | array | titled image gallery |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-20T22:14:00.000Z"` |
| ❗ `error` | string | null | populated only on failure |

#### 📦 Sample records

<details>
<summary><strong>🏞️ Abraham Lincoln Birthplace National Historical Park (KY)</strong></summary>

```json
{
    "id": "77E0D7F0-1942-494A-ACE2-9004D2BDC59E",
    "name": "Abraham Lincoln Birthplace National Historical Park",
    "parkCode": "abli",
    "designation": "National Historical Park",
    "states": "KY",
    "url": "https://www.nps.gov/abli/index.htm",
    "latitude": 37.5858662,
    "longitude": -85.67330523,
    "description": "For over a century people from around the world have come to rural Central Kentucky to honor the humble beginnings of our 16th president, Abraham Lincoln...",
    "phone": "2703583137",
    "email": "ABLI_Administration@nps.gov",
    "operatingHours": [
        {
            "name": "Birthplace Unit",
            "description": "Memorial Building open 9:00 am - 4:30 pm eastern time.",
            "standardHours": {
                "monday": "9:00AM - 5:00PM",
                "tuesday": "9:00AM - 5:00PM",
                "wednesday": "9:00AM - 5:00PM",
                "thursday": "9:00AM - 5:00PM",
                "friday": "9:00AM - 5:00PM",
                "saturday": "9:00AM - 5:00PM",
                "sunday": "9:00AM - 5:00PM"
            }
        }
    ],
    "activities": ["Astronomy", "Stargazing", "Picnicking", "Guided Tours", "Junior Ranger Program", "Birdwatching"],
    "topics": ["Birthplace", "Presidents", "Animals", "Geology", "Night Sky"],
    "addresses": [
        {"line1": "2995 Lincoln Farm Road", "city": "Hodgenville", "stateCode": "KY", "postalCode": "42748", "type": "Physical"}
    ],
    "scrapedAt": "2026-05-20T22:14:00.000Z"
}
```

</details>

<details>
<summary><strong>🏔️ Yosemite National Park (CA)</strong></summary>

```json
{
    "id": "F3F87090-1559-4B57-9F66-AABBA7F39A12",
    "name": "Yosemite National Park",
    "parkCode": "yose",
    "designation": "National Park",
    "states": "CA",
    "url": "https://www.nps.gov/yose/index.htm",
    "latitude": 37.84883288,
    "longitude": -119.5571873,
    "entranceFees": [
        {"cost": 35, "title": "Yosemite Non-commercial Vehicle Pass", "description": "Valid for 7 consecutive days."}
    ],
    "entrancePasses": [
        {"cost": 70, "title": "Yosemite Annual Pass", "description": "Admits one vehicle for one year."}
    ],
    "activities": ["Hiking", "Climbing", "Backpacking", "Camping", "Cycling", "Wildlife Watching"],
    "scrapedAt": "2026-05-20T22:14:00.000Z"
}
```

</details>

<details>
<summary><strong>🏜️ Grand Canyon National Park (AZ)</strong></summary>

```json
{
    "id": "BA1F2153-EFD5-4B92-9966-3E4BC5B40E7E",
    "name": "Grand Canyon National Park",
    "parkCode": "grca",
    "designation": "National Park",
    "states": "AZ",
    "latitude": 36.05444444,
    "longitude": -112.1402778,
    "entranceFees": [{"cost": 35, "title": "Vehicle Pass", "description": "Valid for 7 consecutive days."}],
    "activities": ["Hiking", "Mule Trips", "Rafting", "Camping", "Ranger Programs"],
    "topics": ["Geology", "Erosion", "Canyons", "Native Cultures"],
    "scrapedAt": "2026-05-20T22:14:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏞️ | **Full NPS catalog.** Every National Park, Monument, Historic Site, Seashore, and Recreation Area in one Actor. |
| 🔀 | **Five datasets.** Parks, alerts, campgrounds, events, and fees, all accessible per run. |
| 🇺🇸 | **All states and territories.** 50 states plus DC, PR, USVI, Guam, American Samoa, and the Northern Mariana Islands. |
| ⚡ | **Fast.** 10 parks in under 5 seconds, 470 parks in under three minutes. |
| 🔁 | **Always fresh.** Every run pulls live NPS data, so your dataset reflects current hours, fees, and alerts. |
| 🇺🇸 | **Official source.** Maintained by the National Park Service and the U.S. Department of the Interior. |
| 🚫 | **No keys to manage.** Default sample key works out of the box. |

> 📊 NPS is the canonical reference for U.S. national parks and is used by every major travel, outdoor, and trip-planning product.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ NPS Parks Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **470+ NPS units** | **Live per run** | endpoint, state, park code, keyword | ⚡ 2 min |
| Build your own pipeline | Free, but engineering hours | Full NPS if you build it | Manual | DIY | 🐢 Days |
| Commercial travel data vendors | $500+/month | Vendor-curated subset | Vendor cadence | Vendor's | ⏳ Hours |
| Per-park manual lookups | Free | One park at a time | Manual | None | 🕒 Weeks |

Pick this Actor when you want every NPS unit in a single normalized shape with hours, fees, activities, and alerts ready to drop into your app.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the NPS Parks Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a dataset (parks, alerts, campgrounds, events, or fees), optionally filter by state or park code, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🧳 Travel & Trip Planning

- National park autocomplete with canonical park codes
- Trip-planning maps with coordinates and activities
- Hours and fees overlays for itinerary builders
- Activity-based filtering for adventure trips

</td>
<td width="50%" valign="top">

#### 🏕️ RV, Camping & Outdoor

- Campground inventory with amenities and accessibility
- Reservation-page deep linking
- Activity catalogs for outdoor gear and content brands
- Off-season planning with alerts and closures

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📱 Mobile Apps & Tours

- Self-guided tour data with addresses and directions
- Push notifications tied to live alerts
- Gallery feeds for app onboarding screens
- Multi-park itinerary builders

</td>
<td width="50%" valign="top">

#### 📰 Media, Journalism & Education

- Park profile pages for travel publications
- Educational content for K-12 and homeschool curricula
- Investigative reporting on closures, fees, or events
- Public-interest data visualizations

</td>
</tr>
</table>

***

### 🔌 Automating NPS Parks Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes of the `alerts` endpoint keep your trip-planning app aligned with current closures and advisories.

***

### 🌟 Beyond business use cases

National park data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Conservation-science research with cited park boundaries
- Tourism-economics studies using fee and visitation data
- Coursework in geography, ecology, and public administration
- Reproducible studies with versioned dataset pulls

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal bucket-list trackers for park visitors
- Indie travel apps and photo portfolios
- Educational content for outdoor creators
- Map-art and visualization side projects

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Friends-of-the-Parks group communications
- Indigenous-history advocacy tied to park topics
- Volunteer-coordination for park stewardship
- Civic transparency around fees and alerts

</td>
<td width="50%">

#### 🧪 Experimentation

- Train park-classification or image-matching models
- Prototype agent pipelines that recommend parks by activity
- Build dashboards correlating alerts with weather
- Validate trip-planning recommendation engines

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20National%20Park%20Service%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20National%20Park%20Service%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20National%20Park%20Service%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20National%20Park%20Service%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick which dataset you want (parks, alerts, campgrounds, events, or fees), optionally filter by state or park code, and click Start. The Actor pulls the matching NPS records and writes a clean per-record row to the dataset.

#### 📏 How fresh is the data?

NPS updates its catalog regularly as parks change hours, post new alerts, adjust fees, or add events. Every run of this Actor pulls live data, so your dataset reflects the current NPS state at run time.

#### 🌐 Which parks are covered?

Every NPS unit: National Parks, National Monuments, National Historic Sites, National Seashores, National Recreation Areas, National Battlefields, and more (470+ total across all 50 states and territories).

#### 🏕️ Can I get campground info?

Yes. Set `endpoint` to `campgrounds` to pull NPS-operated campgrounds with reservation info, amenities, accessibility, and contact details.

#### ⚠️ Can I monitor alerts and closures?

Yes. Set `endpoint` to `alerts` and schedule a daily run to track active closures, advisories, and safety alerts across the system.

#### 💲 What is the difference between fees and passes?

Entrance fees are per-visit costs (e.g. a 7-day vehicle pass at $35). Entrance passes are longer-term passes (e.g. an annual park pass at $70 or the America the Beautiful interagency pass). Both are returned per park.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. Daily refreshes of the `alerts` endpoint are ideal for trip-planning apps; weekly refreshes of `parks` keep your directory current.

#### ⚖️ Is this data legal to use?

NPS data is published as U.S. government open data. The values are free to use, including for commercial products, subject to the NPS terms of service.

#### 💼 Can I use this data commercially?

Yes. Public NPS data is widely used in commercial travel, outdoor, and trip-planning products. You are responsible for complying with the NPS terms.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from interrupted runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

NPS Parks Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe park data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh NPS data into your travel-app backend, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**✈️ OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport reference dataset
- [**🔌 AFDC EV Stations Scraper**](https://apify.com/parseforge/afdc-ev-stations-scraper) - U.S. alternative fuel and EV charging stations
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**🏨 Agoda Scraper**](https://apify.com/parseforge/agoda-scraper) - Hotel availability, pricing, and reviews
- [**🏥 CMS Open Data Scraper**](https://apify.com/parseforge/data-cms-gov-scraper) - Centers for Medicare & Medicaid Services open data

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the U.S. National Park Service or the U.S. Department of the Interior. All trademarks mentioned are the property of their respective owners. Only publicly available NPS data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `endpoint` (type: `string`):

Which NPS dataset to export.

## `stateCode` (type: `string`):

Optional two-letter state code filter (US states and territories). Leave blank for all states.

## `parkCode` (type: `string`):

Optional comma-separated park codes (e.g. 'yose,grca,zion'). Leave blank for all parks.

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

Optional free-text search keyword. Example: 'volcano', 'civil war'.

## `apiKey` (type: `string`):

Optional personal key for higher rate limits. Leave blank to use the public sample key.

## Actor input object example

```json
{
  "maxItems": 10,
  "endpoint": "parks"
}
```

# 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 = {
    "maxItems": 10,
    "endpoint": "parks",
    "stateCode": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nps-parks-api-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 = {
    "maxItems": 10,
    "endpoint": "parks",
    "stateCode": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nps-parks-api-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "endpoint": "parks",
  "stateCode": ""
}' |
apify call parseforge/nps-parks-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/nps-parks-api-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "National Park Service Parks Scraper",
        "description": "Export U.S. National Park Service data including parks, alerts, campgrounds, events, and fees. Pulls park names, locations, addresses, operating hours, contact info, entrance fees, activities, and topics across 470+ NPS units (national parks, monuments, historic sites, seashores).",
        "version": "1.0",
        "x-build-id": "QXBtXD8kbxHuzpMml"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nps-parks-api-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nps-parks-api-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~nps-parks-api-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nps-parks-api-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~nps-parks-api-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nps-parks-api-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "endpoint": {
                        "title": "Dataset",
                        "enum": [
                            "parks",
                            "alerts",
                            "campgrounds",
                            "events",
                            "fees"
                        ],
                        "type": "string",
                        "description": "Which NPS dataset to export."
                    },
                    "stateCode": {
                        "title": "State (filter)",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "AS",
                            "GU",
                            "MP",
                            "PR",
                            "VI"
                        ],
                        "type": "string",
                        "description": "Optional two-letter state code filter (US states and territories). Leave blank for all states."
                    },
                    "parkCode": {
                        "title": "Park Code (filter)",
                        "type": "string",
                        "description": "Optional comma-separated park codes (e.g. 'yose,grca,zion'). Leave blank for all parks."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional free-text search keyword. Example: 'volcano', 'civil war'."
                    },
                    "apiKey": {
                        "title": "Personal Access Key (optional)",
                        "type": "string",
                        "description": "Optional personal key for higher rate limits. Leave blank to use the public sample key."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
