# Coworker Space Scraper (`crawlerbros/coworker-space-scraper`) Actor

Scrape coworker.com - the world's largest coworking-space directory. Browse by city or country, or free-text search, and get space name, full address, amenities, pricing plans, ratings/reviews, photos, and space type for every listing.

- **URL**: https://apify.com/crawlerbros/coworker-space-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Real estate
- **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 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

## Coworker Space Scraper

Scrape [Coworker.com](https://www.coworker.com) — the world's largest coworking-space
directory, covering 60,000+ listings in 177 countries. Browse spaces by city or by
country, or run a free-text search, and get the full address, space type, amenities,
pricing plans, ratings/reviews, and photos for every listing. No login, no cookies,
no paid proxy required.

### What this actor does

- **Three modes:** `byCity`, `byCountry`, `search` (free text — matches a country, a
  city, or a specific space name)
- **Global coverage:** every country and city Coworker.com indexes
- **Rich per-space data:** full street address, GPS coordinates, space type(s),
  amenities, capacity-tiered pricing plans (per resource type/duration/headcount),
  review rating + review count + sample reviews, photo gallery, nearby transit,
  venue stats (capacity, desk/office/meeting-room counts), booking capability
  (day pass, tours, reservations), and award/network badges
- **Filters:** space type, amenity, minimum rating, minimum total capacity,
  verified-only, include-closed
- **Empty fields are omitted** — every field present in a record is real, extracted
  data (no placeholders, no sentinels)

### Output per coworking space

- `spaceId`, `name`, `displayName`, `sourceUrl`
- `spaceTypes[]` — one or more of: Hot Desk, Dedicated Desk, Private Office, Meeting
  Room, Virtual Office, Lounge, Coworking Space
- `addressLine1`, `addressLine2`, `city`, `citySlug`, `state`, `stateSlug`,
  `country`, `countrySlug`, `countryCode`, `latitude`, `longitude`
- `amenities[]` — e.g. `WiFi`, `24hr member access`, `Standing Desks`, `Gym`
- `images[]`, `mainImageUrl` — full-resolution photo URLs
- `pricingPlans[]` — `{resourceType, duration, capacity, price, priceUsd, accessHours}`
  per plan/capacity-tier the space publishes (e.g. a private office is commonly listed
  at several different headcount capacities, each at its own price; only present when
  the space lists prices)
- `rating`, `reviewCount`, `reviews[]` (only present when the space has reviews)
- `description`
- `isVerified`, `isNew`, `isClosed`
- `isTedxHost` — the space has hosted a TEDx event
- `isCmcaWinner` — the space won a Coworking Member Choice Award
- `isPopular` — Coworker.com's site-side "popular" badge
- `venueCapacity` — total published seating/member capacity (people), when listed
- `deskCount`, `officeCount`, `meetingRoomCount` — published physical-inventory
  counts (desks / private offices / meeting rooms), when listed
- `securityDeposit` — free-text deposit terms (e.g. `"1 month and a half"`), when listed
- `dayPassAvailable`, `dayPassPrice` — single-day drop-in pass availability/price
- `toursAvailable`, `reservationsEnabled` — booking-capability flags
- `createdDate`, `claimedDate`, `maxMeetingRoomCapacity`, `nearbyTransportation[]`
- `currencyCode`
- `recordType: "coworkingSpace"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCity` | `byCity` / `byCountry` / `search` |
| `countrySlug` | string (select) | `united-states` | Country (mode=byCity, byCountry) |
| `citySlug` | string | `new-york/new-york-city` | City URL path after the country (mode=byCity) |
| `searchQuery` | string | `Berlin` | Free-text query — country, city, or space name (mode=search) |
| `spaceType` | string (select) | `any` | Filter to a specific space type |
| `amenity` | string (select) | – | Filter to spaces offering a specific amenity |
| `minRating` | number | – | Drop spaces rated below this (0–5) |
| `minCapacity` | int | – | Drop spaces whose published total capacity is below this (people) |
| `verifiedOnly` | bool | `false` | Only verified/claimed listings |
| `includeClosed` | bool | `false` | Include permanently-closed listings |
| `maxItems` | int | `20` | Hard cap (1–500) |

#### Example: coworking spaces in Berlin with WiFi

```json
{
  "mode": "search",
  "searchQuery": "Berlin",
  "amenity": "High-Speed WiFi",
  "maxItems": 30
}
````

#### Example: all private offices in a whole country

```json
{
  "mode": "byCountry",
  "countrySlug": "singapore",
  "spaceType": "privateOffice",
  "maxItems": 100
}
```

#### Example: verified, highly-rated spaces in a specific city

```json
{
  "mode": "byCity",
  "countrySlug": "united-kingdom",
  "citySlug": "london",
  "verifiedOnly": true,
  "minRating": 4,
  "maxItems": 50
}
```

### Use cases

- **CRE / location intelligence** — map coworking supply and pricing across cities
- **Competitive benchmarking** — compare amenities and pricing between operators
- **Remote-work relocation research** — find verified, well-reviewed spaces before
  visiting a new city
- **Market-entry research** — gauge coworking density per country before expanding
- **Lead generation** — build a contact list of coworking operators by market

### FAQ

**Do I need a proxy or login?** No. The actor works with zero configuration beyond
the input fields above.

**Where does `citySlug` come from?** Copy it straight from a Coworker.com URL. For
`https://www.coworker.com/united-states/new-york/new-york-city`, `countrySlug` is
`united-states` and `citySlug` is `new-york/new-york-city`. Many countries are only
two levels deep, e.g. `https://www.coworker.com/singapore/singapore-river` →
`countrySlug=singapore`, `citySlug=singapore-river`.

**What happens if a space has no listed price or no reviews?** Those fields
(`pricingPlans`, `rating`, `reviewCount`, `reviews`) are simply omitted for that
record — Coworker.com does not publish pricing/reviews for every listing, and the
actor never fabricates a value.

**Why is `mode=search` sometimes slower than `byCity`/`byCountry`?** When the query
matches an individual space name (rather than a city or country), the actor has to
look the space up inside its city's listing pages, which takes one or more extra
requests per match.

**Why did my space-name search return 0 results?** Coworker.com's own search index
matches all words in the query, so a very specific multi-word query (e.g. an exact
brand + landmark combo that never appears together in the listing name) can return
0 hits even though a shorter query (just the brand name, or the brand plus the
city) would match. Try a shorter or partial name, or use `byCity` with the city the
space is in.

**Why does `sourceUrl` return a redirect/challenge page when I `curl` it directly?**
Coworker.com runs bot-management (Incapsula) that challenges non-browser HTTP
clients; the URL is genuine and opens normally in any real browser. Image URLs
(`images[]`, `mainImageUrl`) are served from a separate, unprotected CDN and are
directly fetchable with no special client needed.

**What if I request a city that doesn't exist?** Coworker.com doesn't 404 unknown
city slugs — it silently falls back to serving the country-wide page instead. The
actor detects this fallback and returns 0 records with a clear status message
rather than surfacing unrelated country-wide spaces mislabeled as your city.

**How fresh is the data?** Real-time — every run fetches Coworker.com's live listing
pages at request time.

**Why do some spaces have no `venueCapacity`/`deskCount`/`officeCount`/`meetingRoomCount`?**
Coworker.com only shows these venue-stats for listings whose operator filled them in;
the actor never fabricates a `0` or placeholder — the fields are simply omitted when
the site itself has no figure.

**What does `claimedDate` mean?** The date the listing owner claimed/verified their
listing on Coworker.com (distinct from `createdDate`, which is when the listing was
first added to the directory).

# Actor input Schema

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

What to fetch.

## `countrySlug` (type: `string`):

Country to browse. Required for byCity and byCountry modes.

## `citySlug` (type: `string`):

The coworker.com URL path segment(s) after the country, e.g. `new-york/new-york-city` (US/Canada use state/city) or `london` or `singapore-river`. Copy this directly from a coworker.com city-page URL.

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

Free-text query — matches a country name, a city name, or a specific coworking space name (e.g. `Berlin`, `Germany`, or `WeWork Times Square`).

## `spaceType` (type: `string`):

Only emit spaces offering this resource type.

## `amenity` (type: `string`):

Only emit spaces offering this amenity. Leave blank for no amenity filter.

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

Drop spaces with an average review rating below this (0-5). Spaces with no reviews are excluded when this filter is set.

## `verifiedOnly` (type: `boolean`):

Only emit spaces the site marks as verified/claimed listings.

## `includeClosed` (type: `boolean`):

By default, permanently-closed listings are excluded.

## `minCapacity` (type: `integer`):

Drop spaces whose published total member/seating capacity is below this number. Spaces that don't publish a capacity figure are excluded when this filter is set.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byCity",
  "countrySlug": "united-states",
  "citySlug": "new-york/new-york-city",
  "searchQuery": "Berlin",
  "spaceType": "any",
  "amenity": "",
  "verifiedOnly": false,
  "includeClosed": false,
  "maxItems": 20
}
```

# Actor output Schema

## `spaces` (type: `string`):

Dataset containing all scraped coworking-space listings.

# 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": "byCity",
    "countrySlug": "united-states",
    "citySlug": "new-york/new-york-city",
    "searchQuery": "Berlin",
    "spaceType": "any",
    "amenity": "",
    "verifiedOnly": false,
    "includeClosed": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/coworker-space-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": "byCity",
    "countrySlug": "united-states",
    "citySlug": "new-york/new-york-city",
    "searchQuery": "Berlin",
    "spaceType": "any",
    "amenity": "",
    "verifiedOnly": False,
    "includeClosed": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/coworker-space-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": "byCity",
  "countrySlug": "united-states",
  "citySlug": "new-york/new-york-city",
  "searchQuery": "Berlin",
  "spaceType": "any",
  "amenity": "",
  "verifiedOnly": false,
  "includeClosed": false,
  "maxItems": 20
}' |
apify call crawlerbros/coworker-space-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coworker Space Scraper",
        "description": "Scrape coworker.com - the world's largest coworking-space directory. Browse by city or country, or free-text search, and get space name, full address, amenities, pricing plans, ratings/reviews, photos, and space type for every listing.",
        "version": "1.0",
        "x-build-id": "BDBg7XQgvZP64Qw48"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~coworker-space-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-coworker-space-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~coworker-space-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-coworker-space-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~coworker-space-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-coworker-space-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": [
                            "byCity",
                            "byCountry",
                            "search"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byCity"
                    },
                    "countrySlug": {
                        "title": "Country (mode=byCity, byCountry)",
                        "enum": [
                            "afghanistan",
                            "albania",
                            "algeria",
                            "andorra",
                            "angola",
                            "antigua-and-barbuda",
                            "argentina",
                            "armenia",
                            "aruba",
                            "australia",
                            "austria",
                            "azerbaijan",
                            "bahamas",
                            "bahrain",
                            "bangladesh",
                            "barbados",
                            "belarus",
                            "belgium",
                            "belize",
                            "benin",
                            "bermuda",
                            "bolivia",
                            "bosnia-and-herzegovina",
                            "botswana",
                            "brazil",
                            "brunei",
                            "bulgaria",
                            "burkina-faso",
                            "cambodia",
                            "cameroon",
                            "canada",
                            "cape-verde",
                            "cayman-islands",
                            "chad",
                            "chile",
                            "china",
                            "colombia",
                            "costa-rica",
                            "cote-divoire",
                            "croatia",
                            "cyprus",
                            "czech-republic",
                            "denmark",
                            "djibouti",
                            "dominican-republic",
                            "ecuador",
                            "egypt",
                            "el-salvador",
                            "equatorial-guinea",
                            "estonia",
                            "ethiopia",
                            "fiji",
                            "finland",
                            "france",
                            "french-polynesia",
                            "gabon",
                            "gambia",
                            "georgia",
                            "germany",
                            "ghana",
                            "gibraltar",
                            "greece",
                            "grenada",
                            "guadeloupe",
                            "guam",
                            "guatemala",
                            "guernsey",
                            "guinea",
                            "guyana",
                            "haiti",
                            "honduras",
                            "hong-kong",
                            "hungary",
                            "iceland",
                            "india",
                            "indonesia",
                            "iraq",
                            "ireland",
                            "isle-of-man",
                            "israel",
                            "italy",
                            "jamaica",
                            "japan",
                            "jersey",
                            "jordan",
                            "kazakhstan",
                            "kenya",
                            "kuwait",
                            "kyrgyzstan",
                            "laos",
                            "latvia",
                            "lebanon",
                            "lesotho",
                            "libya",
                            "liechtenstein",
                            "lithuania",
                            "luxembourg",
                            "macedonia",
                            "madagascar",
                            "malawi",
                            "malaysia",
                            "mali",
                            "malta",
                            "martinique",
                            "mauritius",
                            "mexico",
                            "moldova",
                            "monaco",
                            "mongolia",
                            "montenegro",
                            "morocco",
                            "mozambique",
                            "myanmar",
                            "namibia",
                            "nepal",
                            "netherlands",
                            "netherlands-antilles",
                            "new-zealand",
                            "nicaragua",
                            "niger",
                            "nigeria",
                            "norway",
                            "oman",
                            "pakistan",
                            "palestine",
                            "panama",
                            "paraguay",
                            "peru",
                            "philippines",
                            "poland",
                            "portugal",
                            "puerto-rico",
                            "qatar",
                            "reunion",
                            "romania",
                            "russia",
                            "rwanda",
                            "san-marino",
                            "saudi-arabia",
                            "scotland",
                            "senegal",
                            "serbia",
                            "seychelles",
                            "singapore",
                            "sint-maarten",
                            "slovakia",
                            "slovenia",
                            "somalia",
                            "south-africa",
                            "south-korea",
                            "spain",
                            "sri-lanka",
                            "sudan",
                            "suriname",
                            "sweden",
                            "switzerland",
                            "taiwan",
                            "tajikistan",
                            "tanzania",
                            "thailand",
                            "the-democratic-republic-of-the-congo",
                            "togo",
                            "trinidad-and-tobago",
                            "tunisia",
                            "turkey",
                            "turks-and-caicos-islands",
                            "uganda",
                            "ukraine",
                            "united-arab-emirates",
                            "united-kingdom",
                            "united-states",
                            "uruguay",
                            "uzbekistan",
                            "venezuela",
                            "vietnam",
                            "zambia",
                            "zimbabwe"
                        ],
                        "type": "string",
                        "description": "Country to browse. Required for byCity and byCountry modes.",
                        "default": "united-states"
                    },
                    "citySlug": {
                        "title": "City path (mode=byCity)",
                        "type": "string",
                        "description": "The coworker.com URL path segment(s) after the country, e.g. `new-york/new-york-city` (US/Canada use state/city) or `london` or `singapore-river`. Copy this directly from a coworker.com city-page URL.",
                        "default": "new-york/new-york-city"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query — matches a country name, a city name, or a specific coworking space name (e.g. `Berlin`, `Germany`, or `WeWork Times Square`).",
                        "default": "Berlin"
                    },
                    "spaceType": {
                        "title": "Space type filter",
                        "enum": [
                            "any",
                            "hotDesk",
                            "dedicatedDesk",
                            "privateOffice",
                            "meetingRoom",
                            "virtualOffice",
                            "lounge",
                            "coworkingSpace"
                        ],
                        "type": "string",
                        "description": "Only emit spaces offering this resource type.",
                        "default": "any"
                    },
                    "amenity": {
                        "title": "Amenity filter",
                        "enum": [
                            "",
                            "10 Minute Walk From Public Transit",
                            "24hr member access",
                            "3D Printer",
                            "5 Minute Walk From Public Transit",
                            "AR Equipment",
                            "Accelerator programs",
                            "Air Conditioning",
                            "Alcohol available for purchase",
                            "Apple TV",
                            "Arcade Games",
                            "Art Gallery",
                            "Beanbags",
                            "Bike Parking",
                            "Board Games",
                            "Bocce ball",
                            "Bosu Ball Chairs",
                            "Car Share",
                            "Catering Kitchen",
                            "Childcare",
                            "Chromecast",
                            "Co-living Accommodation",
                            "Coffee For Purchase",
                            "Community App",
                            "Community Drinks",
                            "Community Lunches",
                            "Computers (Macs)",
                            "Computers (PCs)",
                            "Darts",
                            "Drone",
                            "Dual / Single Monitors",
                            "Ergonomic Chairs",
                            "Event Space For Rent",
                            "Events",
                            "Facebook Group for Members",
                            "Free Beer",
                            "Free Coffee",
                            "Free Drinking Water",
                            "Free Snacks",
                            "Free Tea",
                            "Free Wine",
                            "Gluten Free Menu",
                            "Greenscreen",
                            "Gym",
                            "Halal Menu",
                            "Hammocks",
                            "Heating",
                            "High-Speed WiFi",
                            "Incubator programs",
                            "Karaoke",
                            "Kitchen",
                            "Laundry Service",
                            "Library",
                            "Lounge / Chill-out Area",
                            "Makerspace",
                            "Massages",
                            "Meditation Room",
                            "Mentorship Programs",
                            "Microphone",
                            "Mini Golf Course",
                            "Nap Room",
                            "Nearby Airbnb",
                            "Onsite Airbnb",
                            "Onsite Barista",
                            "Onsite Cafe",
                            "Onsite Restaurant",
                            "Organized Sports Team",
                            "Outdoor Terrace",
                            "Paleo Menu",
                            "Parking",
                            "Personal Lockers",
                            "Pet friendly",
                            "Phone Booth",
                            "Photo Studio",
                            "Photocopier",
                            "Ping Pong Table",
                            "Pitching events",
                            "Plug In For Electric Cars",
                            "Podcasting Room ",
                            "Pool Table",
                            "Printer",
                            "Professional Lighting Equipment",
                            "Projector",
                            "Recording Studio",
                            "Retail Space",
                            "Scanner",
                            "Screen Printer",
                            "Showers ",
                            "Shuffleboard ",
                            "Slack Channel For Members",
                            "Snacks Available for Purchase",
                            "Sound Recording Equipment",
                            "Standing Desks",
                            "Swimming Pool",
                            "Table Football / Foosball",
                            "Toastmasters",
                            "Trampoline",
                            "Vegan Menu",
                            "Vegetarian Menu",
                            "Video Recording Equipment",
                            "Volleyball court",
                            "Wheelchair Accessibility",
                            "Workshops",
                            "Yoga Studio"
                        ],
                        "type": "string",
                        "description": "Only emit spaces offering this amenity. Leave blank for no amenity filter.",
                        "default": ""
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop spaces with an average review rating below this (0-5). Spaces with no reviews are excluded when this filter is set."
                    },
                    "verifiedOnly": {
                        "title": "Verified spaces only",
                        "type": "boolean",
                        "description": "Only emit spaces the site marks as verified/claimed listings.",
                        "default": false
                    },
                    "includeClosed": {
                        "title": "Include permanently closed spaces",
                        "type": "boolean",
                        "description": "By default, permanently-closed listings are excluded.",
                        "default": false
                    },
                    "minCapacity": {
                        "title": "Minimum total capacity (people)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop spaces whose published total member/seating capacity is below this number. Spaces that don't publish a capacity figure are excluded when this filter is set."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
