# Giggster Scraper — Event Venue, Film & Photo Space Leads (`scrapersdelight/giggster-space-scraper`) Actor

Scrape every bookable space on Giggster: film, photo, event and meeting venues with hourly rate, per-activity rate ladder, capacity, square footage, amenities, house rules, rating, bookings, host and the local film-permit office. Pick a city and press Start, or paste a Giggster search URL.

- **URL**: https://apify.com/scrapersdelight/giggster-space-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Business, Travel
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 per space returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Giggster Scraper — Event Venue, Film & Photo Space Leads

Scrape bookable spaces from [Giggster](https://giggster.com) — the marketplace productions and
event planners rent locations on. **One row = one live listing**, carrying **title, space type,
category, description, city, state, ZIP, country, neighborhood, latitude/longitude, hourly rate,
currency, the per-activity rate ladder (production / event / meeting), minimum booking length,
capacity, square footage, amenities, features, house rules, star rating, review count, bookings
count, acceptance rate, superhost badge, host name, host company, host website, cover image, the
local film-permit office** and both timestamps Giggster keeps.

Pick a city from the dropdown, or paste a Giggster search URL out of your browser. Filter by city,
state, country, category, space type, bookable activity, price, capacity, square footage, rating or
superhost status.

**No login. No API key. No CAPTCHA. No proxy needed** — Giggster serves plain HTML.

**Scope, measured live on 2026-08-12, not quoted from a marketing page:** the catalogue sitemap
listed **13,556 live listings with 0 duplicates**, and Giggster publishes city pages for **231
cities** (5,908 of them). Los Angeles alone resolves to **1,088 distinct listings**.

***

### Quick start

```json
{
  "city": "los-angeles--ca",
  "maxItems": 25
}
```

That is literally the input this Actor ships with. Click **Try for free**, press **Start**, change
nothing. Measured on the Apify platform, no proxy: **5 city pages read + 29 listing pages fetched →
25 rows in 9.5 seconds**, costing $0.10.

1. Create a free Apify account (no card).
2. Open the Actor and hit **Try for free**.
3. Leave the input alone, or pick a different city from the 231-entry dropdown — or paste a
   Giggster URL into **Or paste Giggster URLs**.
4. Press **Start**. A 25-space run finishes in well under a minute.
5. Open the **Dataset** tab and switch between the three views — **Bookable spaces** (the full
   table), **Leads** (host, company, website, rate, capacity, traction) and **Film & photo
   locations** (style, crew capacity, production rate, permit office).
6. Export CSV / JSON / Excel, or pull it from the API.

Roughly **three minutes from signup to a downloaded CSV**.

#### Copy to your AI assistant

```text
scrapersdelight/giggster-space-scraper on Apify.
Call: ApifyClient("TOKEN").actor("scrapersdelight/giggster-space-scraper").call(run_input={...}),
then client.dataset(run["defaultDatasetId"]).list_items().items for results.
Key inputs: city (string, one of 231 slugs like "los-angeles--ca", or "" for the whole catalogue,
default "los-angeles--ca"), startUrls (array of {url} — giggster.com /find/, /search/ or /listing/
URLs; overrides city), maxItems (int, default 25), minHourlyRate/maxHourlyRate/minCapacity/
minSquareFeet (int, 0 = off), minRating (string enum "0".."5"), superhostOnly (bool),
includeImages (bool), includeActivities (bool), skip (int).
Billing: $0.004 per space returned, charge event "space-scraped". No actor-start charge.
Full actor spec: GET https://api.apify.com/v2/acts/scrapersdelight~giggster-space-scraper
(Bearer TOKEN). Get a token: https://console.apify.com/account/integrations
```

***

### Highlights

- 🏙️ **City-scoped in one hop.** Picking a city reads Giggster's own city pages first, so the
  listing pages it then fetches are already in that city — measured: **1,088 of 1,088 Los Angeles
  candidates came back with `city: "Los Angeles"`.**
- 🔗 **Paste-and-go.** A `/find/`, `/search/` or `/listing/` URL copied from your address bar works
  as the input.
- 🎬 **The film-permit office**, with its phone number, on 74.5% of Los Angeles rows.
- 💵 **A per-activity rate ladder** — production, event and meeting are priced separately, and this
  Actor keeps all three rather than blending them.
- 📐 Capacity on **100%** of rows, coordinates on 100%, square footage on 87% of a Los Angeles city
  run and 85.3% of the catalogue.
- 🧾 **Every run prints its own measured field fill** in the log, so you can audit the numbers below.
- 🚫 **Fails loudly.** Zero rows throws with the HTTP counts; a 20%-parse-failure rate throws rather
  than shipping degraded rows; a shrunken sitemap refuses to pass off a partial catalogue.
- 💳 Charged per space **returned** — never for a page fetched and then filtered out.

***

### What you get per space

| Group | Fields |
|---|---|
| **Identity** | `title`, `spaceType`, `category`, `description`, `url`, `slug`, `id`, `listingStatus` |
| **Location** | `city`, `state`, `zip`, `country`, `neighborhood`, `latitude`, `longitude`, `coordsAreApproximate`, `street` |
| **Price** | `hourlyRate`, `currency`, `productionHourlyRate`, `eventHourlyRate`, `meetingHourlyRate`, `maxHourlyRate`, `minBookingHours` |
| **Size & capacity** | `maxCapacity`, `capacityByActivity`, `capacityIsBanded`, `standingCapacity`, `sittingCapacity`, `squareFeet`, `bedrooms`, `bathrooms` |
| **What it's for** | `activityGroups` (production / event / meeting / play), `activities` (the full slug list, opt-in), `amenities`, `features`, `rules`, `details`, `style`, `cateringInHouseAllowed`, `cateringExternalAllowed` |
| **Traction** | `rating`, `reviewCount`, `ratingCount`, `bookingsCount`, `acceptanceRatePct`, `isSuperhost` |
| **Host** | `hostName`, `hostCompany`, `hostWebsite`, `hostCity`, `hostId`, `hostMemberSince`, `hostEmailVerified`, `hostPhoneVerified` |
| **Media & permits** | `coverImage`, `imageCount`, `images` (opt-in), `filmPermitOffices` |
| **Freshness** | `createdAt`, `updatedAt`, `hostUpdatedAt`, `scrapedAt` |

All timestamps are ISO-8601 UTC exactly as Giggster publishes them. `hourlyRate` is a number in the
listing's own `currency`. Optional fields are returned as `null`, never dropped, so your CSV columns
stay stable between runs.

***

### Who buys this, and which field they monetize

| Who | What they are after | The fields that pay |
|---|---|---|
| **Venue-management & event-booking SaaS** (Perfect Venue, Tripleseat, Peerspace-adjacent tools) | Owners who already rent their space out for money — a pre-qualified SaaS lead | `hostName`, `hostCompany`, `hostWebsite`, `bookingsCount`, `isSuperhost`, `city` |
| **Production-services marketplaces** (equipment, crew, catering, permits) | Every location shooting in a metro, plus who to call about the permit | `filmPermitOffices`, `activityGroups`, `city`, `maxCapacity` |
| **Location scouts & production managers** | A filterable board of spaces by look, size, rate and rules before pitching a client | `style`, `features`, `squareFeet`, `productionHourlyRate`, `rules`, `coverImage` |
| **Event planners & wedding pros** | Venues that actually accept events at a given headcount and price | `eventHourlyRate`, `capacityByActivity`, `cateringExternalAllowed`, `minBookingHours` |
| **Short-term-rental & real-estate analysts** | Hourly-rate comps per city, and how much of the market is proven | `hourlyRate` quartiles, `squareFeet`, `bookingsCount`, `acceptanceRatePct` |
| **Insurance, permitting and compliance vendors** | Spaces with published house rules that imply a coverage requirement | `rules`, `maxCapacity`, `category`, `zip` |

A worked example: a production-services marketplace launching in Toronto sets `city:
"toronto--on"`, `maxItems: 397`, leaves every filter empty, and gets the 397 spaces Giggster's own
Toronto pages expose for **$1.59** — each with the host, the hourly rate, the crew capacity and the
permit office to call.

***

### The wedge: three things the other Giggster and venue scrapers do not give you

**1. `filmPermitOffices`.** Giggster names the local film-permit authority for the jurisdiction, with
its phone number — `{"jurisdiction": "Los Angeles", "organization": "Film L.A.", "phone": "(213)
977-8600"}`. Measured at **74.5% of 200 Los Angeles rows** (23.3% across a whole-catalogue sample,
because most of the catalogue is outside the big permit jurisdictions). No venue directory and no
Maps listing carries this.

**2. `capacityByActivity` and the rate ladder.** Giggster prices and caps *production* (film/photo
crews), *events*, *meetings* and *play* separately, and most hosts enable only some. A blended
"capacity: 60" is a lie on a space that takes 60 for a shoot and 25 for a party. This Actor keeps
`{"production": 60, "event": 60, "meeting": 60}` alongside `productionHourlyRate` /
`eventHourlyRate` / `meetingHourlyRate`, and only trusts the number for activities the host
actually offers.

**3. City runs that do not waste your time.** Giggster's listing index carries no city, so a
naive city filter has to fetch a listing before it can tell where it is — a live Los-Angeles-only
run against the sitemap fetched **221 pages to emit 15 rows**. Picking a city instead reads
Giggster's own city pages, which cost 5 fetches and hand back a pre-filtered list. Measured on
2026-08-12:

| City | City pages | Distinct listings found | In that city |
|---|---|---|---|
| `los-angeles--ca` | 251 | **1,088** | 1,088 / 1,088 |
| `toronto--on` | 163 | 397 | 397 / 397 |
| `nashville--tn` | 60 | 143 | 143 / 143 |

***

### Read this before you buy rows

1. **City mode is Giggster's ranking, not a random sample.** City pages lead with the venues
   Giggster promotes, so a city run skews to the marketed end of the catalogue: **98.5% of 200 Los
   Angeles rows carried a star rating against 37.0% catalogue-wide, and 77.5% were superhosts
   against 17.3%.** That is usually what a lead buyer wants — but do not quote city-mode fill as if
   it described all of Giggster. Both tables are published below.
2. **City mode reaches what Giggster's city pages expose, not provably every listing in the city.**
   1,088 Los Angeles listings is what 251 city pages union to; there is no page that promises it is
   the complete Los Angeles set. Choose **Whole catalogue** when completeness matters more than
   speed.
3. **Capacity is banded at the top.** Giggster's listing page prints "60+ people" once a space
   exceeds 60, so **30% of the 200 Los Angeles rows (and 28.8% catalogue-wide) report
   `maxCapacity: 60` with `capacityIsBanded: true`** when the real number may be 200 or 400. Filter
   on minimum capacity above 60 and you will lose genuine large venues. Use `capacityIsBanded` to
   spot them.
4. **The street address is not public.** Giggster hides the exact address until a booking is
   confirmed and blurs the map pin. `city` / `state` / `zip` are exact; `latitude` / `longitude` are
   deliberately offset and flagged `coordsAreApproximate: true`. **`street` was populated on 0 of
   200 Los Angeles rows** and on under 1% of a catalogue-wide sample.
5. **Prices are in the listing's own currency.** 84% USD, 12.5% CAD, then SGD, AUD, EUR and NZD.
   Read `hourlyRate` together with `currency` — the min/max rate filters compare raw numbers and do
   not convert.

***

### Field fill — measured, both ways

#### A. City mode — 200 Los Angeles spaces, run 2026-08-12

Every one of the 200 was unique (`id`), every one had `city: "Los Angeles"` and `country: "US"`.

| Field | Fill | Field | Fill |
|---|---|---|---|
| **title, description, url, id, slug** | **100%** | reviewCount | 92.0% |
| **city, state, ZIP, country** | **100%** | acceptanceRatePct | 89.5% |
| **latitude / longitude** | **100%** | **squareFeet** | **87.0%** |
| **hourlyRate + currency** | **100%** | eventHourlyRate | 86.5% |
| productionHourlyRate, maxHourlyRate | 100% | spaceType | 85.5% |
| minBookingHours | 100% | meetingHourlyRate | 85.5% |
| **maxCapacity, capacityByActivity** | **100%** | hostCity | 84.0% |
| activityGroups | 100% | **filmPermitOffices** | **74.5%** |
| **hostName**, hostId, hostMemberSince | **100%** | style | 70.5% |
| isSuperhost, bookingsCount | 100% | **hostCompany** | **56.0%** |
| coverImage, imageCount | 100% | cateringExternalAllowed | 52.5% |
| listingStatus, createdAt, updatedAt | 100% | standing / sitting limit | 52.0 / 51.5% |
| **rating, ratingCount** | **98.5%** | bathrooms / bedrooms | 50.5 / 46.5% |
| details | 98.5% | cateringInHouseAllowed | 28.0% |
| rules | 94.5% | neighborhood | 27.0% |
| amenities | 94.0% | **hostWebsite** | **7.0%** |
| features | 92.5% | **street** | **0.0%** |

Quartiles on the same 200 rows: hourly rate **$65.25 / $110 / $200** (range $10–$2,000); capacity
**30 / 60 / 60**; 197 of 200 had at least one booking; 155 of 200 were superhosts.

#### B. Whole catalogue — 400 listings at even stride across the entire sitemap, 2026-08-12

This is the catalogue, not the popular end of it. **Plan against this table if you are running
Whole-catalogue mode.**

| Field | Fill | Field | Fill |
|---|---|---|---|
| title, description | 100% | amenities | 88.3% |
| city, ZIP, country | 100% | square footage | 85.3% |
| latitude / longitude | 100% | house rules | 84.8% |
| hourly rate + currency | 100% | features | 83.5% |
| min booking length | 100% | space type | 82.5% |
| **capacity** | **100%** | meeting hourly rate | 65.3% |
| activity groups | 100% | event hourly rate | 63.3% |
| host name | 100% | style | 49.5% |
| bookings count | 100% | sitting / standing limit | ~42% |
| cover image + count | 100% | **star rating** | **37.0%** |
| category | 99.8% | host company | 34.8% |
| state / province | 96.5% | acceptance rate | 32.8% |
| | | bedrooms / bathrooms | ~27% |
| | | reviews | 25.5% |
| | | film-permit office | 23.3% |
| | | superhost badge | 17.3% |
| | | neighborhood | 5.8% |

**The headline that could mislead you: this is not a contact-details product.** There are no host
e-mail addresses or phone numbers anywhere on Giggster, `hostWebsite` is 7.0%, and `street` is zero.
What you are buying is the space, its economics and its owner's name — see *Honest limits*.

**And traction is not fill.** `bookingsCount` is published on 100% of rows, but catalogue-wide only
about a third of listings have ever been booked (34.0% of a 300-listing even-stride sample, 38% on
the 400-listing one) against 197 of 200 in the Los Angeles city run above. Table A is the marketed
end of Giggster; Table B is Giggster.

Every run prints its own measured fill for nine key fields in the log.

***

### What the catalogue looks like

Same 400-listing catalogue sample:

- **Countries** — US 83.8%, Canada 12.8%, then Singapore, Australia, New Zealand, Ireland and
  Portugal. (A wider API sample also puts the UK near 3%.)
- **Categories** — commercial 47%, residential 31%, studio 18.7%, transportation 3.3% (300-listing
  sample). Those four are the only ones in real use.
- **Bookable for** — production (film & photo) 97.3%, meetings 65.3%, events 63.3%, play 4.8%.
- **Hourly rate** — 25th percentile $95, median $150, 75th percentile $300; the sample spanned $2 to
  $5,500 per hour.
- **Capacity** — 25th percentile 30, median 45, 75th percentile 60 (see the banding caveat).
- **Square footage** — 25th percentile 1,100, median 2,000, 75th percentile 4,860.
- **Biggest cities** — Los Angeles by a wide margin, then Brooklyn, New York, Vancouver, London,
  Toronto, Atlanta, Chicago, Las Vegas, Miami, Montréal and Nashville.

***

### How to run it

#### 1. A city (the default, and the cheapest per row)

```json
{ "city": "los-angeles--ca", "maxItems": 200 }
```

Reads Giggster's city pages for that city, then fetches only those listings. Measured: 15 city
pages + 201 listing fetches → 200 rows in 27 seconds. 231 cities are available; the largest by
number of city pages are `los-angeles--ca` (251), `new-york--ny` (214), `atlanta--ga` (212),
`chicago--il` (207), `vancouver--bc` (185), `houston--tx` (169), `las-vegas--nv` (167),
`toronto--on` (163), `dallas--tx` (158), `miami--fl` (158), `austin--tx` (141),
`philadelphia--pa` (140), `seattle--wa` (140).

#### 2. Paste a URL from your browser

```json
{
  "startUrls": [
    { "url": "https://giggster.com/search/New-York--NY--USA/filming" },
    { "url": "https://giggster.com/find/los-angeles--ca/wedding" },
    { "url": "https://giggster.com/listing/nela-vintage-church-turned-creative-space" }
  ],
  "maxItems": 50
}
```

Three shapes are accepted:

```text
https://giggster.com/find/<city-slug>                 city page          ~20 spaces
https://giggster.com/find/<city-slug>/<activity>      city + activity    ~20 spaces
https://giggster.com/search/<Place>/<activity>        search page        mapped to its city page
https://giggster.com/listing/<slug>                   one listing        1 space
```

Giggster renders `/search/` results in the browser and ships **zero** listings in that page's HTML,
so a pasted search URL is resolved to the matching `/find/` city page — the same city and activity,
just the server-rendered twin. Paste several and they are unioned and deduplicated. Anything in
`startUrls` overrides the City dropdown. A URL that is none of these shapes stops the run with an
error that names the three, instead of quietly returning nothing.

#### 3. The whole catalogue

```json
{ "city": "", "maxItems": 1000, "categories": ["studio"] }
```

Walks `sitemap-listings.xml` (13,556 listings on 2026-08-12). Complete — and the cheapest way to
buy rows in bulk, because with no filters set every page fetched becomes a billable row. Filters
here are applied *after* each page is fetched, so a narrow one walks a lot of pages: it costs you
runtime, never money.

#### 4. Paging across runs

```json
{ "city": "los-angeles--ca", "maxItems": 500, "skip": 500 }
```

Both the sitemap order and the city-page order are stable, so `skip` continues where the last run
stopped instead of re-buying the same spaces. The log tells you which number to use next.

***

### Sample row

A real row from a run on 2026-08-12, trimmed only where noted.

```jsonc
{
  "source": "giggster",
  "id": "bbeb68d6-3978-47a6-aa64-196269b75d91",
  "slug": "nela-vintage-church-turned-creative-space",
  "url": "https://giggster.com/listing/nela-vintage-church-turned-creative-space",

  "title": "Authentic Vintage Church & Creative Space",
  "spaceType": "church",
  "category": "commercial",
  "description": "\"One of the dopest locations in LA…\"",   // truncated here, full text in the row

  "hostName": "Karen S.",
  "hostCompany": "Cosmic Shift Bar, LLC",
  "hostWebsite": null,
  "hostCity": "AL",
  "hostId": "0253abfd-41bd-4bfa-945d-a478e7f62bcc",
  "hostMemberSince": "2019-08-10T03:26:33.351986Z",
  "hostEmailVerified": true,
  "hostPhoneVerified": true,
  "isSuperhost": true,
  "acceptanceRatePct": 83.33,

  "street": null,
  "neighborhood": "Glassell Park",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90065",
  "country": "US",
  "latitude": 34.108610595763174,
  "longitude": -118.23439752095025,
  "coordsAreApproximate": true,

  "currency": "USD",
  "hourlyRate": 100,
  "productionHourlyRate": 100,
  "eventHourlyRate": 125,
  "meetingHourlyRate": 100,
  "maxHourlyRate": 300,
  "minBookingHours": 2,

  "maxCapacity": 60,
  "capacityByActivity": { "production": 60, "event": 60, "meeting": 60 },
  "capacityIsBanded": true,
  "standingCapacity": 65,
  "sittingCapacity": 65,
  "squareFeet": 9695,
  "bedrooms": null,
  "bathrooms": null,
  "style": "Americana/Anywhere America",

  "activityGroups": ["event", "meeting", "production"],
  "amenities": ["Air Conditioning", "Hair/Makeup area", "Wifi"],
  "features": ["Stained Glass Windows", "Brick Walls", "Exposed Beams", "High Ceiling"],  // 16 in the row
  "rules": ["Adult filming", "Alcohol", "Cooking", "Electricity usage", "External catering/food",
            "Loud noises", "Pets", "Smoking"],   // 13 in the row — the last 5 are host-written

  "cateringExternalAllowed": true,
  "cateringInHouseAllowed": null,

  "rating": 4.98412698507309,
  "reviewCount": 126,
  "ratingCount": 316,
  "bookingsCount": 316,

  "imageCount": 81,
  "coverImage": "https://giggster.com/images/location/bbeb68d6-…/92dad802-….jpg",
  "filmPermitOffices": [
    { "jurisdiction": "Los Angeles", "organization": "Film L.A.", "phone": "(213) 977-8600" }
  ],

  "listingStatus": "published",
  "createdAt": "2019-08-10T03:26:12.577159Z",
  "updatedAt": "2026-08-13T00:05:52.021103Z",
  "hostUpdatedAt": "2026-04-03T16:41:00.223568Z",
  "scrapedAt": "2026-08-13T01:51:58.010Z"
}
```

Fields people misread:

- `rating` is Giggster's 0–5 star average, unrounded. `reviewCount` (126 here) counts written
  reviews; `ratingCount` (316) counts scored bookings — they are different numbers and both are
  published.
- `bookingsCount: 0` means "never booked"; `null` means Giggster did not publish the field.
- `capacityIsBanded: true` means the number is Giggster's "60+" ceiling, not the venue's real limit.
- `maxHourlyRate` is the top of the listing's own rate ladder (peak/weekend/long-day tiers), not a
  market maximum.
- `hostCity` is what the host typed into their profile — "AL" here — not the space's location. Use
  `city` / `state` for the space.

***

### Input

Fields in the order they appear in the Console.

| Field | Type | Default | What it does |
|---|---|---|---|
| `city` | select (232) | `los-angeles--ca` | Which of Giggster's 231 city pages to scrape, or **Whole catalogue** (`""`) for all 13,556 listings. A city run is city-pure: 1,088 of 1,088 LA candidates came back in LA. |
| `startUrls` | requestListSources | `[]` | Paste `/find/`, `/search/` or `/listing/` URLs. Overrides `city`. |
| `cities` | stringList | `[]` | Extra text filter on the city field, in Giggster's spelling. Mostly for Whole-catalogue mode. |
| `states` | stringList | `[]` | 2-letter state / province codes: CA, NY, TX, BC, ON. |
| `countries` | stringList | `[]` | 2-letter country codes. US 83.8%, CA 12.8% of the catalogue. |
| `categories` | multi-select | `[]` | commercial 47% · residential 31% · studio 18.7% · transportation 3.3%. |
| `spaceTypes` | stringList | `[]` | 59 exist; 14% of listings leave it blank and are dropped when you set this. |
| `activityGroup` | select | `any` | production 97.3% · meetings 65.3% · events 63.3% · play 4.8%. |
| `minCapacity` | number | `0` | Above 60 you lose banded rows — 28.8% of the catalogue. |
| `minHourlyRate` | number | `0` | Raw number in the listing's own currency; no conversion. |
| `maxHourlyRate` | number | `0` | Same. 0 = no ceiling. |
| `minSquareFeet` | number | `0` | Drops the 14.7% with no published size. |
| `minRating` | select | `Any rating` | A floor here discards the 63.0% with no rating at all. |
| `superhostOnly` | checkbox | `false` | Keeps 17.3% of the catalogue (77.5% of a Los Angeles city run). |
| `includeImages` | checkbox | `false` | +1 request per space; one listing carried 319 photos. Same price. |
| `includeActivities` | checkbox | `false` | 30–220 slugs per row. Free, but fat. |
| `maxItems` | number | `25` | **Your hard cost cap.** 25 = $0.10, 1,000 = $4.00. |
| `skip` | number | `0` | Resume paging across runs. |
| `maxConcurrency` | number | `5` | 5 measured 300/300 pages at 9.7 pages/s. Max 10. |
| `proxyConfiguration` | proxy | off | Off on purpose — see the transport ladder. |

Nothing is required. `default` and `prefill` agree on every field, so an API caller and a Console
user get identical runs.

***

### Pricing

**$0.004 per space returned — $4.00 per 1,000 spaces.** Charged on the `space-scraped` event. There
is **no charge to start a run** and no monthly platform fee from this Actor.

| Run | Spaces | Cost |
|---|---|---|
| The prefilled default (Los Angeles) | 25 | **$0.10** |
| One mid-size city, e.g. Toronto | 397 | **$1.59** |
| Los Angeles, everything the city pages expose | 1,088 | **$4.35** |
| The whole live catalogue | 13,556 | **$54.22** |

- You are charged for **rows delivered**, never for a listing page that was fetched and then removed
  by your filters, and never for the city pages the Actor reads to find them. The default run
  fetched 34 pages and billed 25 rows.
- Rows are charged **as they are pushed** (`Actor.pushData(items, 'space-scraped')`), so if you hit
  a budget cap you get whole rows and a clean stop, not a half-billed dataset.
- Duplicates are dropped before anything is fetched, so the same space is never billed twice within
  a run.
- `maxItems` is your hard cost ceiling and it is also the cost dial.

***

### Honest limits

- **No host e-mail addresses and no phone numbers. Anywhere.** Giggster does not publish them, for
  any listing, and this Actor makes no attempt to find them. If a Giggster scraper advertises "host
  contact information", it means the host's public first name and last initial — which you also get
  here — not a mailbox. `hostWebsite` is your enrichment handle and it is **7.0%** on Los Angeles
  rows. If you need contactable venue and vendor rows, use
  [eventective-scraper](https://apify.com/scrapersdelight/eventective-scraper) or
  [thebash-scraper](https://apify.com/scrapersdelight/thebash-scraper) instead, and use this Actor
  for the space economics.
- **No street address.** 0 of 200 Los Angeles rows and under 1% of the catalogue. Giggster reveals
  it after a booking is confirmed. `latitude`/`longitude` are deliberately blurred and say so via
  `coordsAreApproximate`. This is a Giggster policy, not a scraping failure.
- **Only 37.0% of the catalogue carries a star rating** (98.5% in a Los Angeles city run, because
  city pages promote reviewed venues). Giggster is younger than Airbnb and most listings have never
  been reviewed. If you are prospecting, leave `minRating` at "Any rating" and use `bookingsCount`
  — published on 100% of rows — as your proof-of-life signal. But read a zero as real: **only about
  a third of the catalogue has ever been booked** — 34.0% of a 300-listing even-stride sample
  measured 2026-08-13, 38% on the original 400-listing sample — against 197 of 200 in a Los Angeles
  city run.
- **28.8% of the catalogue reports a banded capacity of 60.** Giggster itself prints "60+". A
  minimum-capacity filter above 60 discards real large venues; `capacityIsBanded` tells you which
  rows are affected.
- **City mode is a ranked slice, not a census.** 1,088 Los Angeles listings is the union of 251
  Giggster city pages, and no page promises that is every LA space. Whole-catalogue mode is the
  complete one.
- **Small cities are small.** 17 of the 231 cities have only 3 city pages, and a city page carries
  20 listings — so a small-city run can legitimately return a few dozen rows and then warn you it
  ran out. That is Giggster's inventory, not a fault.
- **Prices are not currency-converted**, and the min/max rate filters compare raw numbers across
  USD, CAD, SGD, AUD, EUR and NZD.
- **`spaceType` is blank on 14% of listings**, so a space-type filter silently drops them.
- **No login, no cookies, no CAPTCHA solving, and no attempt on any challenge.** Everything here is
  read from pages Giggster serves anonymously.

***

### Measured, not estimated

Everything in this section was measured live on 2026-08-12 with retries switched off.

#### How it works

1. **City runs** read `sitemap-find.xml` — an index of **5,908 `/find/{city}[/{activity}]` landing
   pages across 231 cities** — take that city's family of pages, and parse the `initial-locations`
   JSON blob each one server-renders (20 listings per page; there is no page 2 — `?page=2`, `?p=2`
   and `?offset=20` all return the same 20). Unioned, that is Giggster's only city-scoped
   enumeration.
2. **Whole-catalogue runs** read `sitemap-listings.xml`: one flat urlset, **13,557 `<loc>` entries,
   13,557 unique, 0 duplicates**, of which 13,556 are listing URLs. The Actor refuses to run if that
   file returns fewer than 8,000 URLs rather than quietly emitting a partial slice.
3. Each `/listing/{slug}` page server-renders its whole store as
   `<script type="application/json" data-gig-selector="…">` blobs. `location` is the record;
   `location-details`, `location-amenities`, `location-features`, `location-rules`,
   `location-activities`, `price-levels`, `min-hours`, `reviews` and `currency` sit alongside it.
   Capacity comes from the rendered capacity strip and the star rating from the JSON-LD `Product`
   block, because those two are the only fields not in the blobs.

No login, no cookie, no API key, no browser automation. `robots.txt` declares no crawl-delay and
disallows only `/unsupported`, `/unsupported-browser`, `/projects` and `/project-detail` — none of
which this Actor touches.

#### Transport ladder

| Route | Result |
|---|---|
| Direct, concurrency 5, 300 contiguous listings | **300/300 = 100%** @ 9.7 pages/s |
| Direct, concurrency 5, 200 contiguous listings | **200/200 = 100%** @ 10.5 pages/s |
| Apify Proxy (datacenter), concurrency 5, 20 listings | 20/20 = 100% @ 1.4 pages/s |
| Apify Proxy (residential), concurrency 5, 20 listings | 19/20 = 95% @ 0.6 pages/s |

Giggster serves plain HTML with no Cloudflare challenge, so **`proxyConfiguration` is off by
default** — a proxy here only makes the run 6–14× slower. Apify's own IP range is not blocked (the
datacenter rung is 100%), so a platform run needs no proxy at all. City-page discovery measured
6.5–9.7 pages/s over 474 city pages across three cities, 474/474 successful.

#### Uniqueness and dedupe

- A 200-listing contiguous sitemap walk and a 300-listing strided walk each produced **0 duplicate
  listing IDs** (200/200 and 300/300 unique).
- A 200-row Los Angeles **city-mode** run — which unions 15 overlapping city pages — produced
  **200/200 unique IDs**. Candidates are deduplicated on the listing slug *before any listing page
  is fetched*, so your dataset and your bill never hold the same space twice within a run.
- Across runs, use `skip`; the log prints the number to use next.

#### When a run fails

- **Zero rows throws.** The error carries the page count, the network-failure count, the dead-listing
  count, the unparseable count and how many rows your filters removed — and names the filters that
  bite hardest.
- **A markup change throws.** If more than 20% of pages return HTTP 200 with no readable listing
  blob, the run fails rather than shipping degraded rows.
- **A shrunken sitemap throws** rather than passing off a partial catalogue.
- **An unknown city throws** with a suggestion: `"los-angelos--ca" is not one of the 231 cities
  Giggster publishes a city page for … Did you mean: los-angeles--ca?`
- **A URL that is not a Giggster URL throws**, naming the three shapes that work.
- Delisted listings 404 and are counted separately as "dead" — they do not fail the run and are
  never billed.
- **Running out of run time does not fail the run.** The Actor watches the run's own timeout and
  stops claiming new listings ~20 s before it, flushes the rows it already has and finishes
  SUCCEEDED with a status message telling you the `skip` value to resume from. Measured with a
  120-second timeout against the whole catalogue: 1,942 / 2,572 / 3,206 rows on three runs, each
  ending in 100-101 s with every collected row in the dataset. You are billed for the rows you got
  and nothing else.

***

### FAQ

**Does this need a Giggster account, a login or an API key?**
No. Everything is read from pages Giggster serves anonymously. No cookies, no CAPTCHA solving, no
authentication of any kind.

**Can I get host e-mail addresses or phone numbers?**
No — Giggster publishes none, for any listing. You get the host's public name (first name plus last
initial), their company on 56.0% of Los Angeles rows and a website on 7.0%. Nothing on this site can
produce an e-mail address, and this Actor does not pretend otherwise.

**How many spaces can I get for one city?**
As many as Giggster's own city pages expose. Measured: Los Angeles 1,088, Toronto 397, Nashville
143\. Set `maxItems` to that number or higher and the run will tell you in the log when it runs out.

**Can I get the whole catalogue in one run?**
Yes — set City to **Whole catalogue** and `maxItems` to 14000. All 13,556 spaces cost $54.22, and at
the measured 9.7 pages/second that is about 23 minutes.

**My run returned fewer rows than I asked for. Why?**
Either the city ran out of listings (the log says so, with the number), or your filters removed
them. The filters that bite hardest are `minRating` (only 37.0% of the catalogue is rated),
`minSquareFeet` (85.3%) and `spaceTypes` (14% blank).

**Do I get charged for rows my filters removed?**
No. You are billed once per space actually written to the dataset. Filtered-out pages, city pages
and retries cost you nothing.

**Two runs — will I get duplicates?**
Within a run, never: candidates are deduplicated on the slug before anything is fetched (200/200
unique on a contiguous city walk). Across runs, use `skip`, which works because both the sitemap and
the city-page orders are stable.

**Why is the rating fill so different between the two tables?**
Because city pages are ranked. 98.5% of a Los Angeles city run carried a rating against 37.0% of a
random catalogue sample. City mode gives you the venues Giggster markets; catalogue mode gives you
everything.

**Does it need a proxy?**
No, and it is off by default. Direct measured 300/300 pages at 9.7/s; a proxy measured 100% but
6–14× slower. Turn it on only if your Apify account requires an egress proxy.

**Why isn't Peerspace included?**
It was evaluated properly before this Actor shipped. Peerspace's 44 metro sitemaps enumerate
**19,115 listings** with no overlap, its record maps onto this schema field-for-field, and a parser
was written that returned **200/200 pages with 0 duplicates** from an ordinary residential
connection. It is not shipped because it cannot be reached **from Apify**:

| Route | Result |
|---|---|
| Ordinary residential connection (not a shippable rung) | 200/200 = 100% |
| Apify Proxy, datacenter group | **0/20** — HTTP 403, `cf-mitigated: challenge` |
| Apify Proxy, RESIDENTIAL group | **0/20** — HTTP 403, `cf-mitigated: challenge` |
| Apify Proxy, RESIDENTIAL pinned to US | **0/4** — HTTP 403 |
| Pinned session + homepage warm-up + cookie jar | **0/8** — HTTP 403 |

Shipping it would have shipped a source that returns nothing for every buyer, so it was cut rather
than sold. If that changes it will be added as a selectable source with the same output shape.

**Will a run ever succeed with zero rows?**
No. A zero-row run throws, with the scope and the HTTP counts, so a green-but-empty dataset is not a
thing this Actor can produce.

**Something looks wrong — how do I debug it?**
Read the run log: it prints the enumeration counts, the number of city pages fetched, the pages
fetched versus rows emitted, the failure and filter counts, and its own measured field fill for nine
key fields. Then open the Issues tab with the run ID.

**Can I run it on a schedule?**
Yes — use Apify Schedules. `updatedAt` and `hostUpdatedAt` let you diff runs, and `skip` lets you
walk the catalogue a slice at a time.

***

### Related Actors in this fleet

| Actor | What it is | Why you would use it instead |
|---|---|---|
| [tagvenue-scraper](https://apify.com/scrapersdelight/tagvenue-scraper) | Tagvenue event & party venue leads | UK/AU/US hire venues rather than film locations |
| [eventective-scraper](https://apify.com/scrapersdelight/eventective-scraper) | Eventective venue & vendor leads **with e-mail** | You need contactable rows, which Giggster cannot give you |
| [thebash-scraper](https://apify.com/scrapersdelight/thebash-scraper) | The Bash — DJs, bands, photographers | You want the vendors who work the event, not the room |
| [roaminghunger-scraper](https://apify.com/scrapersdelight/roaminghunger-scraper) | Food-truck leads, cuisines and contacts | Catering supply rather than space supply |
| [bounceguide-scraper](https://apify.com/scrapersdelight/bounceguide-scraper) | Bounce-house rental companies with phones and websites | Party-rental suppliers, not venues |

Giggster is where you go for the **film and photo location with its rate ladder and permit office**;
Tagvenue and Eventective are where you go for the **event venue with a contact route**.

***

### Legal & fair use

This Actor reads pages Giggster publishes openly to anonymous visitors and to search engines, via
Giggster's own `robots.txt` sitemaps. It does not log in, does not solve or bypass any challenge,
collects nothing behind authentication, and does not touch the four paths Giggster's `robots.txt`
disallows.

Rows describe businesses and the spaces they rent out, but they do carry a host's public first name
and last initial, which can be personal data. Giggster publishes no host e-mail addresses or phone
numbers and this Actor does not attempt to find them. You are responsible for complying with
Giggster's terms of service and with the law that applies to how you use the results — GDPR/CCPA for
storage and processing, and CAN-SPAM/PECR if you send anything.

Giggster® is a trademark of its owner. This Actor is an independent tool and is not affiliated with,
endorsed by or sponsored by Giggster.

***

### Feedback

Found a missing field, a city that should be in the dropdown, or a filter you need? Open an issue on
the **Issues** tab with the run ID — new fields and filters get added there.

# Actor input Schema

## `city` (type: `string`):

Scrape the spaces Giggster lists on its city pages for this city. Measured 2026-08-12: Los Angeles resolves to 1,088 distinct listings (from 251 city pages) and 1,088 of 1,088 came back with city = Los Angeles; Toronto 397; Nashville 143. Choose "Whole catalogue" instead to walk all 13,556 listings - complete, but the listing index carries no city, so filtering it by city costs roughly one page fetch per listing checked. 231 cities available.

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

Run the search you want on giggster.com, copy the URL out of the address bar and paste it here. Three shapes work: a city page (https://giggster.com/find/los-angeles--ca or .../find/los-angeles--ca/wedding - about 20 spaces per page, unioned when you paste several), a search page (https://giggster.com/search/New-York--NY--USA/filming - mapped onto the matching city page, because Giggster renders search results in the browser and ships none in the HTML), or a single listing (https://giggster.com/listing/edwardian-craftsman). Anything here overrides the City dropdown. A URL that is none of those stops the run with an error naming the three shapes, rather than quietly returning nothing.

## `cities` (type: `array`):

Keep only spaces whose city field matches one of these, case-insensitively, in Giggster's own spelling: "Los Angeles", "Brooklyn", "New York", "Vancouver", "London", "Toronto", "Atlanta", "Chicago", "Las Vegas", "Miami", "Montréal", "Nashville". Mostly useful with "Whole catalogue", where it is the only way to slice by city; redundant once you have picked a City above.

## `states` (type: `array`):

2-letter state or province codes, e.g. CA, NY, TX, GA, BC, ON. Empty = all.

## `countries` (type: `array`):

2-letter country codes. Measured share of a 400-listing catalogue sample: US 83.8%, CA 12.8%, then SG, AU, NZ, IE and PT; a wider API sample also shows GB at about 3%. Empty = all.

## `categories` (type: `array`):

Giggster's top-level category. Only four are really in use. Measured across a 300-listing catalogue sample: commercial 47%, residential 31%, studio 18.7%, transportation 3.3%. Empty = all.

## `spaceTypes` (type: `array`):

The host's specific space type. 59 exist; the common ones are house, photography-studio, event-space-rooftop, office, film-studio, loft-studio, mansion-or-estate, recording-studio, apartment, ranch, dance-studio, warehouse, pool, loft, bar, cafe, church, theater, restaurant, gallery, gym, farm, hospital. 14% of listings leave it blank and are dropped as soon as you set this. Empty = all.

## `activityGroup` (type: `string`):

Keep only spaces the host has opened up for this kind of booking. Giggster prices production (film/photo shoots), event, meeting and play separately, and most hosts enable only some of them. Measured on a 400-listing sample: production 97.3%, meetings 65.3%, events 63.3%, play 4.8%.

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

Drop spaces whose largest allowed headcount is under this. Capacity is present on 100% of listings. Giggster caps its own display at "60+", so 28.8% of rows report 60 with capacityIsBanded = true - set this above 60 and you will lose real 200-person venues. Sample quartiles: 30 / 45 / 60. 0 = no floor.

## `minHourlyRate` (type: `integer`):

Drop spaces cheaper than this per hour, in the listing's own currency - the filter compares raw numbers and does not convert (84% USD, 12.5% CAD, then SGD/AUD/EUR/NZD). Across a 400-listing sample the quartiles are $95 / $150 / $300 per hour. 0 = no floor.

## `maxHourlyRate` (type: `integer`):

Drop spaces more expensive than this per hour, in the listing's own currency. The sampled range was $2 to $5,500 per hour. 0 = no ceiling.

## `minSquareFeet` (type: `integer`):

Drop spaces smaller than this. Square footage is published on 85.3% of listings and the other 14.7% are dropped as soon as you set a floor. Sample quartiles: 1,100 / 2,000 / 4,860 sq ft. 0 = keep everyone.

## `minRating` (type: `string`):

Drop spaces rated below this. HEADS UP: only 37.0% of Giggster listings carry any star rating, so a floor here silently discards nearly two thirds of the catalogue - a new listing with no reviews is still a live venue and a live lead. Use bookingsCount (published on 100% of rows, though only about a third of the catalogue has ever actually been booked) as a proof-of-life signal instead. "Any rating" keeps everyone.

## `superhostOnly` (type: `boolean`):

Keep only listings whose host carries Giggster's superhost badge - a proven, repeat-booking host rather than a dormant listing. Measured at 17.3% of the catalogue, so this drops about five rows in six.

## `includeImages` (type: `boolean`):

Add every photo URL to each row. The listing page ships only the cover shot, so this costs one extra request per space and can multiply your dataset size - one listing in the sample carried 319 photos. It does not change the price: you are still billed once per space.

## `includeActivities` (type: `boolean`):

Add every one of Giggster's bookable activity slugs the space is enabled for ("wedding-reception", "music-video", "corporate-retreat", ...). Typically 30-220 slugs per row, so it is off by default - the compact activityGroups field (production / event / meeting / play) is always returned. Free: no extra request and no extra charge.

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

How many spaces to return. You are billed $0.004 per space returned and never for a page that was fetched and then filtered out, so this is your hard cost ceiling: 25 = $0.10, 1,000 = $4.00, the whole 13,556-space catalogue = about $54.22. Rows are charged as they are pushed, so a budget cap gives you whole rows and stops.

## `skip` (type: `integer`):

Skip this many listings before collecting. Both the sitemap order and the city-page order are stable, so after a maxItems=500 run set skip=500 next time to continue where you stopped instead of re-buying the same spaces. Ignored when you paste listing URLs.

## `maxConcurrency` (type: `integer`):

Parallel page fetches. 5 is the tested default - a 300-listing live run at that setting returned 300 of 300 pages with zero failures at 9.7 pages/second. Giggster does not rate-limit at this level; raise it only if you need to and watch the failure count in the log.

## `proxyConfiguration` (type: `object`):

OFF by default, on purpose. Giggster serves plain HTML with no Cloudflare challenge, no cookie and no login, and a direct run measured 300/300 pages at 9.7 pages/s. Apify Proxy also works (datacenter 20/20, residential 19/20) but runs 6-14x slower, so switch it on only if your account requires an egress proxy.

## Actor input object example

```json
{
  "city": "los-angeles--ca",
  "startUrls": [],
  "cities": [],
  "states": [],
  "countries": [],
  "categories": [],
  "spaceTypes": [],
  "activityGroup": "any",
  "minCapacity": 0,
  "minHourlyRate": 0,
  "maxHourlyRate": 0,
  "minSquareFeet": 0,
  "minRating": "0",
  "superhostOnly": false,
  "includeImages": false,
  "includeActivities": false,
  "maxItems": 25,
  "skip": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per Giggster listing: title, space type, city/state/ZIP, coordinates, hourly rate and per-activity rate ladder, minimum booking length, capacity, square footage, amenities, features, house rules, star rating, bookings, host and the local film-permit office.

# 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 = {
    "city": "los-angeles--ca",
    "startUrls": [],
    "cities": [],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/giggster-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 = {
    "city": "los-angeles--ca",
    "startUrls": [],
    "cities": [],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/giggster-space-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "city": "los-angeles--ca",
  "startUrls": [],
  "cities": [],
  "maxItems": 25
}' |
apify call scrapersdelight/giggster-space-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/giggster-space-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cjJfIwtMfv1JN8382/builds/I8J1ufCHpIDYXAFZ3/openapi.json