# Mindbody Scraper (`crawlerbros/mindbody-scraper`) Actor

Scrape Mindbody's fitness/wellness/beauty studio marketplace (mindbodyonline.com/explore). Search studios, bookable class schedules, virtual classes, or intro-offer deals by location and activity type. Get studio name, address, activity types, ratings, class schedule, and pricing.

- **URL**: https://apify.com/crawlerbros/mindbody-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Mindbody Scraper

Scrape **Mindbody's fitness/wellness/beauty studio marketplace** (mindbodyonline.com/explore) — the platform behind thousands of yoga studios, gyms, spas, salons, and wellness businesses. Search studios, bookable class schedules, virtual/online classes, or intro-offer deals by location and activity type. No login, no API key, no proxy required.

### What this actor does

- **Four modes:** `studios`, `classes`, `virtualClasses`, `deals`
- **43 activity types** — Yoga, Pilates, Barre, Massage, Hair salon, Nails, Personal training, and 36 more, curated from live marketplace data
- **3 business types** — Fitness, Beauty, Wellness (or all combined)
- **Location search** — city/address text (auto-geocoded) or direct latitude/longitude
- **Class schedules** — real bookable class times, instructor names, open spots, capacity, and drop-in pricing, up to 14 days ahead
- **Virtual classes** — nationwide online/livestream classes, no location filter required
- **Intro-offer deals** — promotional first-visit pricing near a location
- **Filters** — minimum studio rating, online-booking-available, free-classes-only, max drop-in price
- **Keyword search** — optional free-text term (e.g. 'hot yoga', 'reformer', a studio brand name), applied server-side by Mindbody's own search alongside businessType/activityType, across all four modes
- **Sort order** — studios can be sorted by distance, rating, or Mindbody's own relevance ranking
- **Empty fields are omitted** — you only ever see fields that were actually found for a record

### Output fields

#### Studios (`mode=studios`)
- `locationId`, `name`, `slug`, `sourceUrl`
- `description`
- `businessTypes[]` (Fitness/Beauty/Wellness), `activityTypes[]`, `activitySubtypes[]`
- `address`, `address2`, `neighborhood`, `city`, `state`, `county`, `postalCode`, `country`, `countryCode`, `phone`, `timezone`
- `latitude`, `longitude`, `distanceKm` (from your search location)
- `rating`, `ratingCount`, `totalDeals`
- `amenities[]`, `businessIdentifiesAs[]`
- `logoUrl`, `stockImageUrl`, `imageUrls[]`
- `onlineBookingAvailable`, `membershipBookable`, `mobileCheckinAllowed`
- `currencyCode`, `currencySymbol`
- `recordType: "studio"`, `scrapedAt`

#### Classes (`mode=classes`) / Virtual Classes (`mode=virtualClasses`)
- `classTimeId`, `className`, `courseName`, `courseDescription`, `courseImageUrl`
- `activityType`, `activitySubtype`
- `startTime`, `endTime`, `durationMinutes`
- `capacity`, `openSpots`, `isFree`, `waitlistAvailable`
- `dropInPriceFrom`, `currency`
- `instructorName`, `instructorBio`, `instructorAvatarUrl` (`mode=classes` only — the virtual-classes endpoint doesn't include instructor data)
- `studioName`, `studioId`, `studioAddress`, `studioCity`, `studioState`, `studioRating`, `distanceKm`, `sourceUrl`
- `isVirtual` (always `true` on `virtualClasses`)
- `recordType: "class"` / `"virtualClass"`, `scrapedAt`

#### Deals (`mode=deals`)
- `dealId`, `name`, `description`, `isIntroOffer`, `isPackage`, `price`, `serviceCategory`, `sessionCount`
- `studioName`, `studioId`, `address`, `city`, `state`, `postalCode`, `phone`, `activityTypes[]`, `studioRating`, `sourceUrl`
- `currencyCode`, `currencySymbol`
- `recordType: "deal"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `studios` | `studios` / `classes` / `virtualClasses` / `deals` |
| `location` | string | `New York, NY` | City/address to search near (auto-geocoded). Not used for `virtualClasses`. |
| `latitude` / `longitude` | number | – | Direct GPS coordinates, overrides `location` |
| `radiusKm` | integer | `40` | Search radius in km (1-200) |
| `sortBy` | string (select) | `distance` | `distance` / `rating` / `relevance` (mode=studios) |
| `businessType` | string (select) | `all` | `all` / `Fitness` / `Beauty` / `Wellness` |
| `activityType` | string (select) | `any` | One of 43 curated activity types, or `any` |
| `keyword` | string | – | Optional free-text search term (e.g. 'hot yoga', 'reformer', a brand name), applied server-side alongside businessType/activityType, all modes |
| `daysAhead` | integer | `3` | How many days ahead to search the class schedule (1-14, mode=classes/virtualClasses) |
| `minRating` | integer | `0` | Minimum studio rating 0-5 (client-side, mode=studios) |
| `onlineBookingOnly` | boolean | `false` | Only studios with online booking enabled (mode=studios) |
| `freeClassesOnly` | boolean | `false` | Only free classes (mode=classes/virtualClasses) |
| `maxPrice` | integer | – | Max drop-in price in USD (client-side, mode=classes/virtualClasses) |
| `maxItems` | int | `30` | Hard cap on returned records (1-500) |

#### Example: yoga studios near Los Angeles

```json
{
  "mode": "studios",
  "location": "Los Angeles, CA",
  "activityType": "Yoga",
  "minRating": 4,
  "maxItems": 30
}
````

#### Example: "hot yoga" studios near Austin (keyword search)

```json
{
  "mode": "studios",
  "location": "Austin, TX",
  "keyword": "hot yoga",
  "sortBy": "rating",
  "maxItems": 30
}
```

#### Example: today's bookable pilates classes in Chicago

```json
{
  "mode": "classes",
  "location": "Chicago, IL",
  "activityType": "Pilates",
  "daysAhead": 1,
  "maxItems": 20
}
```

#### Example: free virtual yoga classes nationwide

```json
{
  "mode": "virtualClasses",
  "activityType": "Yoga",
  "freeClassesOnly": true,
  "maxItems": 20
}
```

#### Example: intro-offer deals for massage near Miami

```json
{
  "mode": "deals",
  "location": "Miami, FL",
  "activityType": "Massage",
  "maxItems": 20
}
```

### Use cases

- **Local fitness/wellness lead generation** — build a prospect list of studios by activity type and city
- **Class discovery apps** — surface today's/this-week's bookable classes near a user
- **Market research** — measure studio density, ratings, and pricing across metros by activity type
- **Deal aggregation** — track intro-offer pricing across studios in a market
- **Competitor mapping** — see who else operates in a category and area, with ratings and amenities

### Limitations

- **US-centric data density.** Mindbody's marketplace is heavily concentrated in US metros; searches in smaller international markets return fewer or no results. `businessType`/`activityType` combinations still apply globally wherever Mindbody has coverage.
- **`minRating`, `onlineBookingOnly`, `freeClassesOnly`, `maxPrice` are applied client-side.** Mindbody's search API has no server-side threshold filter for these, so they're applied across the batch of records this run actually fetched — a low `maxItems` combined with a strict filter may return fewer records than expected.
- **No separate external "website" field.** Mindbody's marketplace API does not expose a studio's own homepage URL — only its Mindbody-hosted booking page (`sourceUrl`), which every listed studio uses as its primary online storefront.
- **`virtualClasses` studios are not filtered by location** — online/livestream classes are searched nationwide by design; `location`/`latitude`/`longitude` inputs are ignored for this mode.

### FAQ

**What's Mindbody?** A booking and business-management platform used by tens of thousands of fitness, wellness, and beauty businesses worldwide, with a public "Explore" marketplace at mindbodyonline.com/explore where consumers search and book classes/appointments.

**Is this affiliated with Mindbody?** No. This is an independent, third-party actor that reads Mindbody's publicly accessible marketplace search API — the same one mindbodyonline.com/explore uses in the browser.

**Why do class records have both `startTime` in UTC-looking format and a `studioState`?** `startTime`/`endTime` are ISO 8601 UTC timestamps as returned by Mindbody; convert to the studio's local time using its `timezone` field from a paired `mode=studios` lookup if needed.

**How is `distanceKm` calculated?** Computed directly from your search coordinates and the studio's own latitude/longitude (haversine great-circle distance), so it's always real, verifiable data rather than relying on Mindbody's own (sometimes-null) distance field.

**Does this actor need a proxy or login?** No — this actor talks directly to Mindbody's public marketplace API using a browser-matching HTTP client, and works entirely on Apify's free plan with no proxy and no credentials.

**Why 43 activity types instead of a free-text field?** Mindbody doesn't publish a "list all categories" endpoint, so this list was built by sampling real search results across major US metros and taking the union of every distinct activity type observed — using a dropdown avoids silent zero-result typos (e.g. "Yoga " vs "yoga").

# Actor input Schema

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

What to fetch.

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

City, town, or address to search near, e.g. 'New York, NY', 'Los Angeles', 'London'. Ignored if latitude/longitude are set. Not used for mode=virtualClasses.

## `latitude` (type: `number`):

GPS latitude for location-based search. Overrides the Location field if provided (together with Longitude).

## `longitude` (type: `number`):

GPS longitude for location-based search. Overrides the Location field if provided (together with Latitude).

## `radiusKm` (type: `integer`):

Radius in kilometres around the location to search.

## `sortBy` (type: `string`):

Order in which studios are returned. 'Distance' is closest-first (default), 'Rating' is highest-rated-first, 'Relevance' matches Mindbody's own marketplace ranking.

## `businessType` (type: `string`):

Top-level Mindbody marketplace category. 'All' searches Fitness, Beauty, and Wellness together.

## `keyword` (type: `string`):

Optional free-text search term (e.g. 'hot yoga', 'reformer', 'crossfit', a studio brand name). Applied server-side by Mindbody's own search alongside businessType/activityType — useful for niches not covered by the 43 curated activity types. Leave blank to search all matching businessType/activityType results.

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

Specific activity/service type to filter by, e.g. Yoga, Pilates, Massage, Hair salon. 'Any' returns every activity type within the selected business type.

## `daysAhead` (type: `integer`):

How many days ahead of today to search the class schedule.

## `minRating` (type: `integer`):

Only return studios rated at least this many stars (0-5). 0 means no minimum. Applied client-side; unrated studios are excluded once this is set above 0.

## `onlineBookingOnly` (type: `boolean`):

Only return studios that support booking directly through their Mindbody online store.

## `freeClassesOnly` (type: `boolean`):

Only return classes Mindbody marks as free.

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

Only return classes whose lowest drop-in price is at or below this amount. Applied client-side; classes with no visible price pass through.

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

Hard cap on the number of records to return.

## Actor input object example

```json
{
  "mode": "studios",
  "location": "New York, NY",
  "radiusKm": 40,
  "sortBy": "distance",
  "businessType": "all",
  "activityType": "any",
  "daysAhead": 3,
  "minRating": 0,
  "onlineBookingOnly": false,
  "freeClassesOnly": false,
  "maxItems": 30
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped Mindbody studios, classes, virtual classes, or deals (depending on mode).

# 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": "studios",
    "location": "New York, NY",
    "radiusKm": 40,
    "sortBy": "distance",
    "businessType": "all",
    "activityType": "any",
    "daysAhead": 3,
    "minRating": 0,
    "onlineBookingOnly": false,
    "freeClassesOnly": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/mindbody-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": "studios",
    "location": "New York, NY",
    "radiusKm": 40,
    "sortBy": "distance",
    "businessType": "all",
    "activityType": "any",
    "daysAhead": 3,
    "minRating": 0,
    "onlineBookingOnly": False,
    "freeClassesOnly": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/mindbody-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": "studios",
  "location": "New York, NY",
  "radiusKm": 40,
  "sortBy": "distance",
  "businessType": "all",
  "activityType": "any",
  "daysAhead": 3,
  "minRating": 0,
  "onlineBookingOnly": false,
  "freeClassesOnly": false,
  "maxItems": 30
}' |
apify call crawlerbros/mindbody-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mindbody Scraper",
        "description": "Scrape Mindbody's fitness/wellness/beauty studio marketplace (mindbodyonline.com/explore). Search studios, bookable class schedules, virtual classes, or intro-offer deals by location and activity type. Get studio name, address, activity types, ratings, class schedule, and pricing.",
        "version": "1.0",
        "x-build-id": "gBB9o7GaadwJJHMfE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~mindbody-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-mindbody-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~mindbody-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-mindbody-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~mindbody-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-mindbody-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": [
                            "studios",
                            "classes",
                            "virtualClasses",
                            "deals"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "studios"
                    },
                    "location": {
                        "title": "Location (city or address)",
                        "type": "string",
                        "description": "City, town, or address to search near, e.g. 'New York, NY', 'Los Angeles', 'London'. Ignored if latitude/longitude are set. Not used for mode=virtualClasses.",
                        "default": "New York, NY"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "GPS latitude for location-based search. Overrides the Location field if provided (together with Longitude)."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "GPS longitude for location-based search. Overrides the Location field if provided (together with Latitude)."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Radius in kilometres around the location to search.",
                        "default": 40
                    },
                    "sortBy": {
                        "title": "Sort by (mode=studios)",
                        "enum": [
                            "distance",
                            "rating",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Order in which studios are returned. 'Distance' is closest-first (default), 'Rating' is highest-rated-first, 'Relevance' matches Mindbody's own marketplace ranking.",
                        "default": "distance"
                    },
                    "businessType": {
                        "title": "Business type",
                        "enum": [
                            "all",
                            "Fitness",
                            "Beauty",
                            "Wellness"
                        ],
                        "type": "string",
                        "description": "Top-level Mindbody marketplace category. 'All' searches Fitness, Beauty, and Wellness together.",
                        "default": "all"
                    },
                    "keyword": {
                        "title": "Keyword (free text)",
                        "type": "string",
                        "description": "Optional free-text search term (e.g. 'hot yoga', 'reformer', 'crossfit', a studio brand name). Applied server-side by Mindbody's own search alongside businessType/activityType — useful for niches not covered by the 43 curated activity types. Leave blank to search all matching businessType/activityType results."
                    },
                    "activityType": {
                        "title": "Activity type",
                        "enum": [
                            "any",
                            "Acupuncture",
                            "Aerial",
                            "Barber",
                            "Barre",
                            "Body treatments",
                            "Bootcamp",
                            "Boxing / kickboxing",
                            "Braids",
                            "Chiropractor",
                            "Circuit training",
                            "Coaching / healing",
                            "Cryotherapy",
                            "Cycling",
                            "Dance",
                            "Face treatments",
                            "Gym classes",
                            "Gymnastics",
                            "Hair removal",
                            "Hair salon",
                            "Heated therapy",
                            "Interval training",
                            "Makeup / lashes / brows",
                            "Martial arts",
                            "Massage",
                            "Med spa",
                            "Meditation",
                            "Nails",
                            "Naturopathic medicine",
                            "Nutrition",
                            "Other",
                            "Outdoor",
                            "Personal training",
                            "Physical therapy / physiotherapy",
                            "Pilates",
                            "Pole Fitness",
                            "Reflexology",
                            "Sports",
                            "Strength training",
                            "Tai chi",
                            "Tanning",
                            "Water therapy",
                            "Weight training",
                            "Yoga"
                        ],
                        "type": "string",
                        "description": "Specific activity/service type to filter by, e.g. Yoga, Pilates, Massage, Hair salon. 'Any' returns every activity type within the selected business type.",
                        "default": "any"
                    },
                    "daysAhead": {
                        "title": "Days ahead (mode=classes/virtualClasses)",
                        "minimum": 1,
                        "maximum": 14,
                        "type": "integer",
                        "description": "How many days ahead of today to search the class schedule.",
                        "default": 3
                    },
                    "minRating": {
                        "title": "Minimum studio rating (mode=studios)",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return studios rated at least this many stars (0-5). 0 means no minimum. Applied client-side; unrated studios are excluded once this is set above 0.",
                        "default": 0
                    },
                    "onlineBookingOnly": {
                        "title": "Online booking available only (mode=studios)",
                        "type": "boolean",
                        "description": "Only return studios that support booking directly through their Mindbody online store.",
                        "default": false
                    },
                    "freeClassesOnly": {
                        "title": "Free classes only (mode=classes/virtualClasses)",
                        "type": "boolean",
                        "description": "Only return classes Mindbody marks as free.",
                        "default": false
                    },
                    "maxPrice": {
                        "title": "Max drop-in price USD (mode=classes/virtualClasses)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Only return classes whose lowest drop-in price is at or below this amount. Applied client-side; classes with no visible price pass through."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of records to return.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
