# Hipcamp Scraper - Campsites and Outdoor Stays (`parseforge/hipcamp-scraper`) Actor

Scrape Hipcamp campsite listings, prices, amenities, reviews, and availability. Extract location details, host information, and photos for outdoor stays and glamping.

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

## Pricing

from $19.00 / 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/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)

## Hipcamp Camping & Glamping Listings Scraper

> 🚀 **Export Hipcamp camping and glamping listings to CSV, JSON, or Excel in seconds.** No login required. No API key needed.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **607+ listings per state** · **All 50 US states**

The Hipcamp Scraper extracts camping and glamping listings from [Hipcamp](https://www.hipcamp.com) - the leading platform for booking unique outdoor stays. Search by US state and collect listing names, types (tent/cabin/RV/glamping), ratings, reviews, pricing, amenities, and direct booking URLs. Data is pulled in real-time from Hipcamp's internal API.

Hipcamp hosts over 300,000 camping sites across private and public lands, including national forests, ranches, wineries, and farms. This actor gives you structured access to that data for any research, business, or development purpose.

### Coverage

- All 50 US states supported
- 607+ listings for major states like California, Texas, and Colorado
- 12 data fields per listing including amenities, price, rating, and images
- Real-time data - no cached responses

### Target Audience / Use Cases

| Who | What They Build |
|---|---|
| Outdoor travel apps | Aggregate camping inventory across platforms |
| Market researchers | Analyze camping trends, pricing, and availability |
| Real estate investors | Identify land with glamping potential |
| Data journalists | Report on the outdoor hospitality industry |
| Developers | Power maps, recommendation engines, travel tools |
| Tourism boards | Benchmark regional camping offerings |

### What the Hipcamp Scraper does

- Scrapes camping and glamping listings by US state
- Collects names, types, star ratings, review counts, and nightly prices
- Extracts amenities (fire pit, showers, WiFi, pets allowed, etc.)
- Returns direct Hipcamp booking URLs for each listing
- Supports optional activity filtering (hiking, fishing, swimming, etc.)
- Respects free/paid plan limits automatically

> 💡 **Why it matters:** Hipcamp is the fastest-growing outdoor hospitality platform in the US. Scraping it lets you track pricing trends, identify gaps in the market, and build tools that connect campers with unique outdoor experiences - data that isn't available through any official API.

### Demo

🚧 Coming soon

### Input

| Field | Type | Description | Required |
|---|---|---|---|
| `state` | string | US state name to search (e.g. `california`, `texas`) | No (default: `california`) |
| `maxItems` | number | Max listings to collect (free: 10, paid: up to 1,000,000) | No (default: 10) |
| `activityType` | string | Optional activity filter (e.g. `hiking`, `fishing`, `swimming`) | No |

**Example - Basic state search:**
```json
{
  "state": "california",
  "maxItems": 100
}
````

**Example - Filtered by activity:**

```json
{
  "state": "colorado",
  "maxItems": 50,
  "activityType": "fishing"
}
```

> ⚠️ **Good to Know:** State names should be lowercase (e.g. `california`, `new york`, `north carolina`). Free users are limited to 10 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock more.

### Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Primary listing photo URL (Cloudinary CDN) |
| 🏕️ `name` | string | Name of the listing |
| 🏠 `type` | string | Accommodation types (tent, rv, house) |
| ⭐ `rating` | string | Recommendation percentage (0-100) |
| 💬 `reviewCount` | string | Total number of reviews |
| 💰 `pricePerNight` | string | Starting price per night (e.g. `$40.00`) |
| 🏙️ `city` | string | City where the listing is located |
| 🗺️ `state` | string | State abbreviation (e.g. `CA`) |
| 🌍 `country` | string | Country code (e.g. `US`) |
| 🔧 `amenities` | string | Comma-separated list of amenities |
| 🔗 `url` | string | Full Hipcamp listing URL |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of collection |
| ❌ `error` | string | Error message if collection failed |

**Sample records:**

```json
[
  {
    "imageUrl": "https://res.cloudinary.com/hipcamp/image/upload/w_600,c_fill,q_auto/images/v1505771313/campground-photos/hhgvwjhy5pjuybqbq6fy/sierra-ranch-cabins-tents-rr-hidden-tent-site-forest-swimming-activity.jpg",
    "name": "Sierra Ranch - Cabins & Tents",
    "type": "house, tent, rv",
    "rating": "98",
    "reviewCount": "615",
    "pricePerNight": "$40.00",
    "city": "Springville",
    "state": "CA",
    "country": "US",
    "amenities": "Pets, Potable water, Toilets, Campfires, Showers, Trash, Cooking equipment, Picnic table, Wifi",
    "url": "https://www.hipcamp.com/en-US/land/california-sierra-ranch-cabins-tents-gzwjhd5v",
    "scrapedAt": "2026-05-21T23:52:16.030Z",
    "error": null
  },
  {
    "imageUrl": "https://res.cloudinary.com/hipcamp/image/upload/w_600,c_fill,q_auto/images/v1716696104/campground-photos/drtfh7cw9sg8maqotc4n/remeadies-intoxicating-potions-boma-oak-retreat.jpg",
    "name": "Remeadies Intoxicating Potions",
    "type": "tent, rv",
    "rating": "99",
    "reviewCount": "36",
    "pricePerNight": "$45.00",
    "city": "Squaw Valley",
    "state": "CA",
    "country": "US",
    "amenities": "Pets, Potable water, Toilets, Trash, Picnic table, Wifi, Television Hookup, Generators",
    "url": "https://www.hipcamp.com/en-US/land/california-remeadies-intoxicating-potions-5x5hxm99",
    "scrapedAt": "2026-05-21T23:52:16.333Z",
    "error": null
  }
]
```

### Why choose this Actor

| Feature | Details |
|---|---|
| 🚀 No login required | Works without a Hipcamp account |
| ⚡ Fast GraphQL API | Direct API access - no slow browser rendering |
| 🔧 Full amenity data | Core, basic, and RV amenities per listing |
| 📍 All 50 US states | Built-in coordinate mapping for every state |
| 💰 Price data | Starting nightly price per listing |
| ⭐ Rating and reviews | Recommendation percentage and review count |
| 🖼️ Image URLs | High-resolution Cloudinary image links |
| 📦 Clean output | No null fields, structured for immediate use |

### How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---|---|---|---|
| State-level search | Yes | Limited | Varies |
| Amenity details | Yes | Click-by-click | Rarely |
| Price data | Yes | Yes | Sometimes |
| Bulk export | Yes (1M+) | No | Limited |
| No login required | Yes | Yes | Varies |
| Activity filters | Yes | Yes | Rarely |

### How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 credit
2. Open the Hipcamp Scraper on Apify Store
3. Set your desired `state` (e.g. `california`)
4. Optionally set `maxItems` and `activityType`
5. Click **Start** and wait for results
6. Download your dataset as CSV, JSON, Excel, or XML

### Business use cases

#### Outdoor Travel and Booking Platforms

Build competitive camping inventory tools. Compare Hipcamp pricing against KOA, ReserveAmerica, or Hipcamp's own public lands data. Track which amenities command premium pricing in each state.

#### Market Research and Competitive Intelligence

Analyze the glamping market. Which states have the most tent-only sites vs. cabin rentals? What is the average price per night in Colorado vs. California? How does review count correlate with price?

#### Real Estate and Land Investment

Identify patterns in how landowners are monetizing acreage through glamping. Use amenity data to understand what investment is needed to compete in a given market.

#### Travel Apps and Recommendation Engines

Power location-aware camping recommendations. Enrich your app's database with real Hipcamp listing data, images, and amenities to give users more options beyond what any single platform shows.

### Automating Hipcamp Scraper

Connect this actor to your favorite automation platforms:

- **Make (Integromat)** - Trigger a scrape weekly and update your Google Sheet with new California listings
- **Zapier** - Push new camping listings to Airtable or Notion as they are collected
- **Slack** - Get notified when a scrape completes with a count of new listings found
- **Google Sheets** - Export results directly into a spreadsheet for analysis
- **n8n** - Build a pipeline that scrapes, enriches, and emails a weekly camping report

### Beyond business use cases

#### Academic Research

Study the distribution of outdoor hospitality across US states. Analyze amenity availability by region, or research how rural land monetization through glamping affects local economies.

#### Personal Travel Planning

Build your own camping wishlist database. Scrape multiple states, filter by amenities (pets allowed, fire pit, WiFi), and organize your bucket-list outdoor stays.

#### Non-profit and Conservation Work

Map the density of private camping land near national parks and forests. Identify regions where private land fills gaps in public camping availability.

#### Developer Experimentation

Use the dataset to prototype location-based apps, test mapping libraries with real geographic data, or build a demo travel application without needing a paid API key.

### Ask an AI assistant about this scraper

Not sure how to integrate this data? Ask an AI assistant: "How do I use the Hipcamp Scraper on Apify to collect camping listings in Texas and load them into a PostgreSQL database?" - the answer will reference this actor directly.

### Frequently Asked Questions

**❓ Do I need a Hipcamp account to use this scraper?**
No. This actor accesses publicly available listing data and does not require you to log in to Hipcamp.

**❓ How many listings can I collect per run?**
Free users get up to 10 listings. Paid users can collect up to 1,000,000 items per run. California alone has 607+ listings.

**❓ Which US states are supported?**
All 50 US states are supported. Use lowercase state names like `california`, `new york`, or `north carolina`.

**❓ Can I filter by activity type?**
Yes. Set `activityType` to values like `hiking`, `fishing`, `swimming`, or `rock climbing` to narrow results to listings that offer that activity.

**❓ How fresh is the data?**
Data is collected in real-time on each run. There is no caching - every run fetches live data from Hipcamp.

**❓ What does the `type` field contain?**
It contains the accommodation types available at each listing, as a comma-separated string. Values include `tent`, `rv`, `house` (cabins/structures), and combinations like `tent, rv, house`.

**❓ What does the `rating` field mean?**
It is the recommendation percentage (0-100) based on guest reviews. A rating of `98` means 98% of guests would recommend the listing.

**❓ Are amenities complete?**
Amenities are fetched from Hipcamp's detail API for each listing. They include core amenities (toilets, water, showers), basic amenities (fire pit, picnic table, WiFi), and RV amenities (hookups, generators) where available.

**❓ Can I export to Excel or CSV?**
Yes. Apify datasets support CSV, JSON, Excel, XML, and HTML export formats from the dataset view.

**❓ Does the price include taxes and fees?**
The `pricePerNight` field shows the base starting price per night as displayed on the listing card. It does not include cleaning fees or service fees.

**❓ What happens if a listing fails to scrape?**
Failed listings receive an `error` field with a description. The scraper continues to the next listing rather than stopping.

**❓ Can I scrape multiple states in one run?**
Currently one state per run. To scrape multiple states, run the actor multiple times with different `state` values, or use Apify's scheduling and dataset merge features.

### Integrate with any app

This actor works with every tool that reads JSON, CSV, or webhooks:

- **Google Sheets** via Apify's Google Sheets integration
- **Airtable** via Zapier or Make
- **Notion** via Make automation
- **PostgreSQL / MySQL** via JSON export and bulk insert
- **BigQuery** via Apify's Google Cloud integration
- **Power BI** via CSV export
- **Tableau** via CSV or JSON connector
- **MongoDB** via JSON export
- **Elasticsearch** via bulk JSON ingestion
- **REST APIs** via Apify webhooks on run completion

### Recommended Actors

| Actor | Description |
|---|---|
| [Recreation.gov Campsites Scraper](https://apify.com/parseforge/recreation-gov-campsites-scraper) | Scrape public campsite availability from Recreation.gov |
| [OpenTable Scraper](https://apify.com/parseforge/opentable-scraper) | Extract restaurant listings and availability |
| [Bstock Scraper](https://apify.com/parseforge/bstock-scraper) | Scrape B-Stock auction listings and pricing data |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering travel, real estate, finance, government data, and more.

***

*This actor is not affiliated with or endorsed by Hipcamp. It accesses publicly available listing data for research and development purposes. Always comply with Hipcamp's Terms of Service and applicable laws when using scraped data.*

# Actor input Schema

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

US state name to search listings in (e.g. california, texas, colorado).

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

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

## `activityType` (type: `string`):

Optional activity filter (e.g. hiking, fishing, swimming). Leave empty for all types.

## Actor input object example

```json
{
  "state": "california",
  "maxItems": 10
}
```

# 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 = {
    "state": "california",
    "maxItems": 10
};

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hipcamp-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 '{
  "state": "california",
  "maxItems": 10
}' |
apify call parseforge/hipcamp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hipcamp Scraper - Campsites and Outdoor Stays",
        "description": "Scrape Hipcamp campsite listings, prices, amenities, reviews, and availability. Extract location details, host information, and photos for outdoor stays and glamping.",
        "version": "0.1",
        "x-build-id": "PkLqWd064FkqByCuC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hipcamp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hipcamp-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~hipcamp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hipcamp-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~hipcamp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hipcamp-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": {
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "US state name to search listings in (e.g. california, texas, colorado)."
                    },
                    "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"
                    },
                    "activityType": {
                        "title": "Activity Type",
                        "type": "string",
                        "description": "Optional activity filter (e.g. hiking, fishing, swimming). Leave empty for all types."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```