# Hipcamp Campsites & Host Scraper (`crawlerbros/hipcamp-scraper`) Actor

Scrape Hipcamp campsite listings, host profiles, and public campgrounds. Search by location, filter by type, amenities, price, and rating. Supports 5 modes: search, get site detail, get host profile, browse by type, and browse by state

- **URL**: https://apify.com/crawlerbros/hipcamp-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Hipcamp Campsites & Host Scraper

Extract campsite listings, host profiles, and public campground data from [Hipcamp](https://www.hipcamp.com) — the largest platform for private and public camping in the United States. Search by location or keyword, browse by state or campsite type, or fetch detailed records for specific campsites and hosts.

No account, login, or API key required.

---

### What does this actor do?

This actor scrapes Hipcamp's public website to collect structured campsite data. It supports five modes:

- **Search campsites** by location keyword (e.g., "Yosemite", "Big Sur", "lake camping Texas")
- **Get campsite detail** for specific Hipcamp land or campground URLs
- **Get host profile** with member-since date, response rate, and listing links
- **Browse by campsite type** (tent, RV, glamping, cabin, treehouse, etc.)
- **Browse all campsites in a US state**

For each campsite it collects: name, description, price per night, rating, review count, amenities, location, images, and a direct booking URL. Host records include profile metadata and their active listings.

---

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `mode` | Select | Scraping mode (see below) | `searchSites` |
| `searchQuery` | Text | Keyword or location to search (e.g. `Yosemite`, `Big Sur`) | `Yosemite` |
| `location` | Text | Alternative to searchQuery: city, state, or region name | — |
| `startUrls` | String List | Hipcamp land/campground URLs for `getSite` or `getHost` modes | — |
| `state` | Select | US state to browse or filter by | — |
| `siteType` | Select | Filter or browse by site type (Tent Camping, RV Camping, Glamping, Cabin, Treehouse, Farm, Ranch, Yurt, Tiny House, Other) | — |
| `minPrice` | Number | Minimum price per night in USD | — |
| `maxPrice` | Number | Maximum price per night in USD | — |
| `minRating` | Number | Minimum rating on a 0–5 scale | — |
| `hasElectric` | Boolean | Only include sites with electric hookup | `false` |
| `petFriendly` | Boolean | Only include pet-friendly sites | `false` |
| `hasWifi` | Boolean | Only include sites with WiFi | `false` |
| `hasWater` | Boolean | Only include sites with potable water | `false` |
| `maxItems` | Number | Maximum number of records to output (1–5000) | `20` |

#### Modes

| Mode | Description | Required Input |
|---|---|---|
| `searchSites` | Search campsites by keyword or location | `searchQuery` or `location` |
| `getSite` | Fetch full detail for specific campsite URL(s) | `startUrls` |
| `getHost` | Extract host profile from a land URL | `startUrls` |
| `byType` | Browse all campsites of a given type | `siteType` |
| `byState` | Browse all campsites in a US state | `state` |

---

### Output

#### Campsite record (`recordType: "campsite"`)

| Field | Type | Description |
|---|---|---|
| `siteId` | String | Hipcamp internal site ID |
| `maskedId` | String | Short masked ID used in URLs (e.g. `lz9hk605`) |
| `name` | String | Campsite or campground name |
| `description` | String | Overview or summary text |
| `siteType` | String | Primary accommodation type |
| `siteTypes` | Array | All accommodation types available |
| `pricePerNight` | Number | Base price per night in USD |
| `currency` | String | Currency symbol (e.g. `$`) |
| `rating` | Number | Rating on a 0–5 scale (converted from Hipcamp's 0–100% recommends) |
| `reviewCount` | Number | Total number of reviews/recommends |
| `hostId` | String | Host's Hipcamp ID (getSite mode) |
| `hostName` | String | Host's display name |
| `hostAvatarUrl` | String | Host profile photo URL |
| `city` | String | City name |
| `state` | String | US state name |
| `country` | String | Country name |
| `countryCode` | String | ISO country code (e.g. `US`) |
| `county` | String | County name |
| `latitude` | Number | Latitude coordinate |
| `longitude` | Number | Longitude coordinate |
| `amenities` | Array | List of amenity names |
| `images` | Array | Cloudinary image URLs (up to 10) |
| `area` | String | Land area (e.g. `15 acres`) |
| `bookingsCount` | Number | Total bookings |
| `isStarHost` | Boolean | Whether the host has Star Host status |
| `isHipbook` | Boolean | Whether bookable via Hipcamp |
| `url` | String | Full Hipcamp URL to the listing |
| `recordType` | String | Always `campsite` |
| `scrapedAt` | String | ISO 8601 timestamp |

#### Host record (`recordType: "host"`)

| Field | Type | Description |
|---|---|---|
| `hostId` | String | Hipcamp host ID |
| `name` | String | Host display name |
| `avatarUrl` | String | Profile photo URL |
| `memberSince` | String | Account creation date |
| `rating` | Number | Aggregated rating (0–5 scale) |
| `reviewCount` | Number | Total reviews across listings |
| `responseRate` | Number | Response rate percentage |
| `responseTime` | String | Typical response time |
| `listings` | Array | List of `{siteId, name, url}` objects |
| `profileUrl` | String | Hipcamp host profile URL |
| `recordType` | String | Always `host` |
| `scrapedAt` | String | ISO 8601 timestamp |

---

### Example output record

```json
{
  "siteId": "185342",
  "maskedId": "lz9hk605",
  "name": "Camping At Yosemite's Doorstep",
  "description": "Reserve your tent site on 15 exclusive, wooded-acres only 10 minutes from the entrance to Yosemite National Park.",
  "siteType": "Tent Camping",
  "siteTypes": ["Tent Camping", "RV Camping"],
  "pricePerNight": 80.0,
  "currency": "$",
  "rating": 4.8,
  "reviewCount": 96,
  "hostName": "John D.",
  "city": "Groveland",
  "state": "California",
  "country": "United States",
  "countryCode": "US",
  "county": "Tuolumne",
  "latitude": 37.816945,
  "longitude": -119.94233,
  "amenities": ["Pets", "Toilets", "Campfires", "Showers", "Potable water", "Picnic table"],
  "images": [
    "https://hipcamp-res.cloudinary.com/c_fill,f_auto,w_800/images/v1711304715/land-photos/jwjksicamze9lkkytprm/camping-at-yosemite-s-doorstep.jpg"
  ],
  "area": "15 acres",
  "bookingsCount": 239,
  "isStarHost": true,
  "isHipbook": true,
  "url": "https://www.hipcamp.com/en-US/land/california-camping-at-yosemite-s-doorstep-lz9hk605",
  "recordType": "campsite",
  "scrapedAt": "2026-05-17T07:30:00+00:00"
}
````

***

### FAQ

**How do I find all campsites in a specific US state?**
Set `mode` to `byState` and choose your state from the `state` dropdown. For example, selecting `California` will browse Hipcamp's California camping listings. Combine with `minRating` or `maxPrice` filters to narrow results.

**Can I filter by amenities like pets or electric hookup?**
Yes. Use the `petFriendly`, `hasElectric`, `hasWifi`, and `hasWater` boolean toggles. These filter results client-side after fetching from Hipcamp. Note: amenity data availability depends on what hosts have listed.

**How do I scrape a specific campsite I found on Hipcamp?**
Copy the campsite URL from your browser (e.g. `https://www.hipcamp.com/en-US/land/california-camping-at-yosemite-s-doorstep-lz9hk605`), set `mode` to `getSite`, and paste the URL(s) into `startUrls`. The actor will fetch full detail including reviews and individual site info.

**Can I scrape host profiles?**
Yes. Use `mode=getHost` with a land URL in `startUrls`. The actor fetches the land detail, extracts the host's profile info (member since, response rate, listings), and outputs a host record.

**How fresh is the data?**
The actor fetches live data from Hipcamp's website at the time of each run. Pricing, availability, and ratings reflect the current state of each listing.

**What campsite types are supported?**
The `siteType` filter supports: Tent Camping, RV Camping, Glamping, Cabin, Treehouse, Farm, Ranch, Yurt, Tiny House, and Other. Both private Hipcamp lands and public campgrounds are returned.

**How is the rating calculated?**
Hipcamp uses a "recommends percentage" (0–100%). This actor converts it to a 0–5 scale by dividing by 20, so 100% → 5.0, 80% → 4.0, etc.

***

### Limitations

- **Date availability** is not scraped. This actor does not check which dates a campsite is available for booking.
- **Booking is not supported.** The actor only extracts public listing data; actual reservations must be made on Hipcamp.
- **Private land locations** may show approximate coordinates rather than exact addresses, as Hipcamp protects exact locations until after booking.
- **Results per search** are limited to what Hipcamp's discover pages surface (~20–40 listings per location). For broader coverage, run multiple queries or use `byState` mode.
- **Public campgrounds** (national parks, state parks) may not have pricing listed if they use an external reservation system (e.g., Recreation.gov).

# Actor input Schema

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

What to scrape. Use `searchSites` to search by keyword/location, `getSite` to fetch detail for specific URLs, `getHost` to extract host profiles, `byType` to browse by campsite type, or `byState` to browse all sites in a US state.

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

Keyword or location to search (e.g. `Yosemite`, `Big Sur`, `lake camping Texas`). Used in `searchSites` mode.

## `location` (type: `string`):

City, state, region, or area name as an alternative to `searchQuery`.

## `startUrls` (type: `array`):

List of Hipcamp campsite or land URLs. Used in `getSite` and `getHost` modes. Example: `https://www.hipcamp.com/en-US/land/california-camping-at-yosemite-s-doorstep-lz9hk605`

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

US state to browse or filter by. Required for `byState` mode; optional filter in other modes.

## `siteType` (type: `string`):

Filter results by campsite type. Also used to select a type category in `byType` mode.

## `minPrice` (type: `integer`):

Only include campsites at or above this nightly price.

## `maxPrice` (type: `integer`):

Only include campsites at or below this nightly price.

## `minRating` (type: `number`):

Only include campsites with a rating at or above this value (0–5 scale).

## `hasElectric` (type: `boolean`):

Only include campsites with electric hookup available.

## `petFriendly` (type: `boolean`):

Only include campsites that allow pets.

## `hasWifi` (type: `boolean`):

Only include campsites with WiFi available.

## `hasWater` (type: `boolean`):

Only include campsites with potable water available.

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

Maximum number of records to output.

## Actor input object example

```json
{
  "mode": "searchSites",
  "searchQuery": "Yosemite",
  "startUrls": [],
  "hasElectric": false,
  "petFriendly": false,
  "hasWifi": false,
  "hasWater": false,
  "maxItems": 20
}
```

# Actor output Schema

## `campsites` (type: `string`):

Dataset containing all scraped campsite listings and host profiles.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "searchSites",
    "searchQuery": "Yosemite",
    "startUrls": [],
    "hasElectric": false,
    "petFriendly": false,
    "hasWifi": false,
    "hasWater": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "searchSites",
    "searchQuery": "Yosemite",
    "startUrls": [],
    "hasElectric": False,
    "petFriendly": False,
    "hasWifi": False,
    "hasWater": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "searchSites",
  "searchQuery": "Yosemite",
  "startUrls": [],
  "hasElectric": false,
  "petFriendly": false,
  "hasWifi": false,
  "hasWater": false,
  "maxItems": 20
}' |
apify call crawlerbros/hipcamp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hipcamp Campsites & Host Scraper",
        "description": "Scrape Hipcamp campsite listings, host profiles, and public campgrounds. Search by location, filter by type, amenities, price, and rating. Supports 5 modes: search, get site detail, get host profile, browse by type, and browse by state",
        "version": "1.0",
        "x-build-id": "u2hKEZOZ6hRHruUY2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~hipcamp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~hipcamp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~hipcamp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchSites",
                            "getSite",
                            "getHost",
                            "byType",
                            "byState"
                        ],
                        "type": "string",
                        "description": "What to scrape. Use `searchSites` to search by keyword/location, `getSite` to fetch detail for specific URLs, `getHost` to extract host profiles, `byType` to browse by campsite type, or `byState` to browse all sites in a US state.",
                        "default": "searchSites"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword or location to search (e.g. `Yosemite`, `Big Sur`, `lake camping Texas`). Used in `searchSites` mode.",
                        "default": "Yosemite"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, region, or area name as an alternative to `searchQuery`."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Hipcamp campsite or land URLs. Used in `getSite` and `getHost` modes. Example: `https://www.hipcamp.com/en-US/land/california-camping-at-yosemite-s-doorstep-lz9hk605`",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "US State",
                        "enum": [
                            "Alabama",
                            "Alaska",
                            "Arizona",
                            "Arkansas",
                            "California",
                            "Colorado",
                            "Connecticut",
                            "Delaware",
                            "Florida",
                            "Georgia",
                            "Hawaii",
                            "Idaho",
                            "Illinois",
                            "Indiana",
                            "Iowa",
                            "Kansas",
                            "Kentucky",
                            "Louisiana",
                            "Maine",
                            "Maryland",
                            "Massachusetts",
                            "Michigan",
                            "Minnesota",
                            "Mississippi",
                            "Missouri",
                            "Montana",
                            "Nebraska",
                            "Nevada",
                            "New Hampshire",
                            "New Jersey",
                            "New Mexico",
                            "New York",
                            "North Carolina",
                            "North Dakota",
                            "Ohio",
                            "Oklahoma",
                            "Oregon",
                            "Pennsylvania",
                            "Rhode Island",
                            "South Carolina",
                            "South Dakota",
                            "Tennessee",
                            "Texas",
                            "Utah",
                            "Vermont",
                            "Virginia",
                            "Washington",
                            "West Virginia",
                            "Wisconsin",
                            "Wyoming"
                        ],
                        "type": "string",
                        "description": "US state to browse or filter by. Required for `byState` mode; optional filter in other modes."
                    },
                    "siteType": {
                        "title": "Campsite type",
                        "enum": [
                            "Tent Camping",
                            "RV Camping",
                            "Glamping",
                            "Cabin",
                            "Treehouse",
                            "Farm",
                            "Ranch",
                            "Yurt",
                            "Tiny House",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter results by campsite type. Also used to select a type category in `byType` mode."
                    },
                    "minPrice": {
                        "title": "Min price per night ($)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only include campsites at or above this nightly price."
                    },
                    "maxPrice": {
                        "title": "Max price per night ($)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only include campsites at or below this nightly price."
                    },
                    "minRating": {
                        "title": "Min rating (0–5)",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include campsites with a rating at or above this value (0–5 scale)."
                    },
                    "hasElectric": {
                        "title": "Electric hookup required",
                        "type": "boolean",
                        "description": "Only include campsites with electric hookup available.",
                        "default": false
                    },
                    "petFriendly": {
                        "title": "Pet friendly required",
                        "type": "boolean",
                        "description": "Only include campsites that allow pets.",
                        "default": false
                    },
                    "hasWifi": {
                        "title": "WiFi required",
                        "type": "boolean",
                        "description": "Only include campsites with WiFi available.",
                        "default": false
                    },
                    "hasWater": {
                        "title": "Potable water required",
                        "type": "boolean",
                        "description": "Only include campsites with potable water available.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to output.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
