# PartySlate Scraper — Event Venue & Vendor Leads (`scrapersdelight/partyslate-venue-scraper`) Actor

Scrape event venues and vendors from PartySlate: venue type or category, city, state, seated and standing capacity, event spaces, website, phone, Instagram, photo counts, published pricing, claimed status. 119 US metros, 48,600 companies, plus every pro credited on 44,593 real events. No login.

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

## Pricing

$4.00 / 1,000 per venue or vendor 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **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

## PartySlate Scraper — Event Venue & Vendor Leads

Event **venues** and event **vendors** from [PartySlate](https://www.partyslate.com). One row is
one company: **name, category or venue type, street, city, state, ZIP, latitude/longitude, Google
Place ID, phone, website, Instagram, seated and standing capacity**, the per-room event-space
breakdown with amenities, published photo and event counts, response time, published pricing and
whether the listing is claimed.

**119 US metros. 18,992 venues + 29,608 vendors = 48,600 companies**, plus **44,593 published real
events** whose credit lists reach pros the directory search never returns — all counted live
through PartySlate's own API, not quoted from a marketing page.

Filter by metro, venue type, vendor category, ownership classification, capacity, published
pricing, claimed status, phone or website — or just paste a PartySlate search URL out of your
browser. **No login. No API key. No cookies. No CAPTCHA solving. No proxy needed.**

```json
{ "listingType": "venues", "locations": ["chicago"], "maxItems": 100 }
```

Click **Try for free** and hit **Start** — that is the input the Actor ships with. It returned
**100 Chicago venues in 7 requests** on the last test run (website 100%, phone 100%, Instagram
99%, capacity 100%).

***

### Quick start

1. Create a free Apify account and open this Actor.
2. Press **Start**. The prefilled input is a real 100-venue Chicago run — nothing to type.
3. To aim it somewhere else, either put a metro in **Metro areas** (`miami`, or just type
   `"New York"` and it is resolved through PartySlate's own geocoder) …
4. … or run the search on partyslate.com in your browser and paste the address bar into
   **Start URLs**. Pasted URLs override every picker.
5. Set **Max results** — it is your cost cap: 100 rows = **$0.40**.
6. Download JSON, CSV or Excel, or read it from the API. Four dataset views ship with the Actor:
   *Venues & vendors*, *Venue leads*, *Vendor leads*, *Real-event credits*.

About **3 minutes** from pressing Start to a downloaded CSV on a 100-row run.

#### Copy to your AI assistant

```text
ScrapersDelight/partyslate-venue-scraper on Apify.
Call: ApifyClient("TOKEN").actor("ScrapersDelight/partyslate-venue-scraper").call(run_input={...}),
then client.dataset(run["defaultDatasetId"]).list_items().items for results.
Key inputs: startUrls (array of partyslate.com /find-venues, /find-vendors or /real-events URLs,
default []), listingType ("venues"|"vendors"|"both"|"real-events", default "venues"),
locations (array of metro slugs, default ["chicago"], empty = all 119 metros),
vendorCategories (array), venueTypes (array), maxItems (int, default 100, = cost cap),
enrichContacts (bool, default true), skip (int, default 0).
Full actor spec: GET https://api.apify.com/v2/acts/ScrapersDelight~partyslate-venue-scraper
(Bearer TOKEN). Get token: https://console.apify.com/account/integrations
```

***

### The wedge: capacity, event spaces and the credit list

Two things here are not on Google Maps and not in any other PartySlate scraper on the store.

**1. Room-level capacity.** A seated or standing capacity is published on **78.9% of venues
nationwide** (a standing figure specifically on 78.3%), and 60.9% of venues in a full-metro walk
carry an `eventSpaces` array —
every bookable room with its own name, seated and standing capacity, space types, amenities and
photo count. A caterer, an AV company or a rental firm qualifies a venue on *how many people fit
in which room*, and that number does not exist on a Maps listing.

**2. The credit list on 44,593 published real events.** Set the source to **Real events** and the
Actor walks PartySlate's published-event gallery and returns every pro the event's author credited
— planner, caterer, florist, photographer, band, rentals, **and the venue**. Measured on a live
run: **509 credit lines across 100 events, of which 348 (68.4%) link to a PartySlate company
record**, giving **303 unique companies** from 100 event fetches. These rows are the *working* end
of the market — 94.0% have claimed their profile, 96.4% publish a website and 88.4% a phone, all
higher than the directory average — and they include companies that a directory search in the same
metro does not surface.

***

### Who buys this

| Buyer | What they monetize |
|---|---|
| **Catering, AV, lighting and rental companies** | `maxCapacity` + `eventSpaces` + `phone`: a venue that seats 250 is a different sale from one that seats 1,200. 78.9% of venues publish a capacity. |
| **Venue-management and event-booking SaaS (Tripleseat, Perfect Venue, Event Temple)** | `isUnclaimed` and `profilePlan`: 32.5% of venues in a whole-metro walk have never claimed their listing — a ready-made target list of venues with no software behind them. |
| **Wedding and event marketplaces building supply** | `listingType: "real-events"` credit rows: pros already proven to work weddings, with `website` at 96.4% and `phone` at 88.4%. |
| **Agencies selling websites and SEO to event pros** | `website` is blank on 13.3% of venues and 21.0% of vendors — that is the pitch list, and `phone` is on 83.4% / 66.4% of them. |
| **Supplier-diversity and procurement teams** | `diversityClassifications` — 20.8% of vendors self-declare Woman / Black / Hispanic or Latinx / Veteran / LGBTQ+ ownership, filterable server-side. |
| **Corporate event planners and sourcing platforms** | `minimumSpendUsd` and `pricePerGuestUsd` on the 15.7% of venues that publish pricing, plus `responseTime` to rank who actually answers. |

***

### Read this before you buy rows

#### 1. Two record types, one shape

`listingType: "venues"` returns event spaces. `listingType: "vendors"` returns the event
businesses around them. `"both"` returns both **in one dataset with identical columns** — venue
fields are `null` on vendor rows and vice versa, and every row carries a `listingType` flag.
Nothing is merged into a ragged schema.

#### 2. `photoCount` is not the same measurement on both types

| | what `photoCount` counts |
|---|---|
| **venues** | photos across the venue's published **event spaces** (the room galleries) |
| **vendors** | the vendor's **entire published portfolio** |

That is why a vendor commonly shows 3,000+ and a venue shows 40. PartySlate does not publish a
whole-profile photo total for venues anywhere, so this Actor sums what the site does publish
rather than inventing a number. Venue rows with no published spaces get `null`, not `0`.

#### 3. Vendors are listed at city level, venues at street level

Vendors are service businesses; **only 8.5%** publish a street address. `city`, `state`,
`latitude`/`longitude` and `address` are still 100%. Venues are the opposite — 94.7% carry a full
street address and 92.8% a ZIP.

#### 4. Results come **paying-listings-first**

PartySlate ranks its own search by subscription tier — platinum, then premier, then the free
`basic` listings, which are 94% of the directory. So a `maxItems: 100` run returns the premium
end of the market with **much** higher field fill than the directory average. Both numbers are
published below; use the one that matches the run you are about to pay for.

#### 5. Real-event rows are contact-rich and structure-poor

A credit line is a link, not a listing. Those rows carry **no capacity, no event spaces, no photo
counts, no published pricing and no description** — measured 0.0% on all five across 250 rows.
What they do carry is contacts, better than the directory does. Table D below is the one to plan
against if you use that source.

#### 6. `eventType` re-ranks, it does not filter

PartySlate accepts an event type on both searches and echoes it back, but the matching pool is
identical with and without it: New York photographers return **406 either way**, Los Angeles
returns **1,214 venues either way**. Only the order changes. On a capped run that decides *which*
wedding-first companies you get; on an uncapped run it changes nothing but the sequence. This
Actor sends it and says so rather than selling it as a filter.

***

### What you get

One row per company. All dates are ISO-8601 UTC; all money fields are numbers in USD.

| Group | Fields |
|---|---|
| **Identity** | `listingType` (`venue`/`vendor`) · `companyId` · `name` · `slug` · `profileUrl` · `category` · `categorySlug` · `services` · `venueTypes` · `amenities` |
| **Location** | `street` · `city` · `state` · `stateCode` · `postalCode` · `country` · `address` · `latitude` · `longitude` · `googlePlaceId` |
| **Contact** | `phone` (E.164) · `phoneFormatted` · `website` · `instagramUrl` |
| **Capacity (venues)** | `seatedCapacity` · `standingCapacity` · `maxCapacity` · `eventSpaceCount` · `eventSpaces[]` (name, seated, standing, types, amenities, photoCount) |
| **Traction** | `photoCount` · `publishedEventCount` · `albumCount` · `testimonialCount` · `yearsInBusiness` · `foundedYear` · `responseTime` |
| **Money** | `minimumSpendUsd` · `pricePerGuestUsd` · `minimumBudgetUsd` · `hasPublishedPricing` |
| **Segmentation** | `diversityClassifications` · `topEventTypes[]` · `travelOption` · `isUnclaimed` · `profilePlan` |
| **Lead hygiene** | `isClosed` (PartySlate's permanently-closed flag) · `closedAt` (ISO date it closed, or `null`). Both come from the company profile, so they are populated only when **Enrich contacts** is on (the default); with enrichment off they stay `null`. |
| **Real-event provenance** | `creditedService` (the role the event author credited them for) · `sourceEventId` |
| **Media & provenance** | `description` · `coverImageUrl` · `logoUrl` · `searchLocation` · `scrapedAt` |

Optional fields are `null`, never dropped, so your CSV columns stay stable across runs.

***

### Measured, not estimated

Every number on this page came from a run. Nothing is rounded up, and the unflattering rows are
in the same tables as the good ones.

**A. Complete metro, every listing including free ones.** Whole Chicago corpus scraped end to
end — the numbers you get when you take everything:

| Field | Venues (n=1,279) | Vendors (n=1,916) |
|---|---:|---:|
| `name`, `city`, `state`, `address`, `latitude`/`longitude`, `profileUrl` | **100%** | **100%** |
| `stateCode` | 100% | 99.7% |
| **`website`** | **86.7%** | **79.0%** |
| `description` | 85.8% | 75.3% |
| **`phone`** | **83.4%** | **66.4%** |
| `googlePlaceId` | 88.0% | 76.9% |
| `instagramUrl` | 77.6% | 67.7% |
| `street` / `postalCode` | 94.7% / 92.8% | 8.5% / 7.8% |
| `maxCapacity` (seated or standing) | 72.6% | — |
| `venueTypes` | 60.5% | — |
| `eventSpaceCount` / `amenities` | 60.9% / 44.6% | — |
| `photoCount` | 57.1% | 84.2% |
| `publishedEventCount` | 44.5% | 64.4% |
| `albumCount` | — | 83.3% |
| `services` | — | 51.1% |
| `responseTime` | 24.0% | 28.5% |
| `yearsInBusiness` / `foundedYear` | — | 26.7% |
| `diversityClassifications` | — | 20.8% |
| `hasPublishedPricing` | 16.6% | 20.0% |
| `testimonialCount` > 0 | 12.3% | 9.7% |
| claimed listings (`isUnclaimed: false`) | 67.5% | 83.5% |
| **`email`** | **0%** | **0%** |

**B. Nationwide, all 119 metros, 48,600 companies.** The same sweep this Actor performs when you
leave `locations` empty (listing fields only — the contact lookup was not run on all 48,600):

| Venues (n=18,992) | | Vendors (n=29,608) | |
|---|---:|---|---:|
| name / address | 100% | name / category / state | 100% |
| standing capacity | 78.3% | city | 99.8% |
| any capacity | 78.9% | description | 79.3% |
| phone | 80.9% | photo count | 75.2% |
| description | 84.4% | album count | 73.7% |
| event spaces | 55.6% | phone | 60.3% |
| venue types | 55.0% | published events | 58.3% |
| photo count | 47.0% | services | 41.9% |
| response time | 19.0% | response time | 27.0% |
| published pricing | 15.7% | years in business | 25.3% |

**C. A 100-row run** hits the platinum/premier end of the ranking. The shipped default input
(100 Chicago venues) most recently returned **website 100%, phone 100%, Instagram 99%, capacity
100%, published pricing 53%**. Real, but not representative of the whole directory — see §4.

**D. The real-events source**, measured on **250 companies pulled from 100 published events
across all six event categories** (509 credit lines, 161 of them text-only with no PartySlate
profile behind them), 2026-08-12:

| Field | Fill |
|---|---:|
| `name`, `profileUrl`, `category`, `creditedService`, `sourceEventId`, `address`, `latitude`/`longitude`, `state` | **100%** |
| `publishedEventCount` | 99.6% |
| `city` | 99.2% |
| `stateCode` | 98.4% |
| **`website`** | **96.4%** |
| `logoUrl` | 95.6% |
| `instagramUrl` | 94.8% |
| claimed listings (`isUnclaimed: false`) | 94.0% |
| **`phone`** | **88.4%** |
| `googlePlaceId` | 86.4% |
| **`maxCapacity`, `eventSpaces`, `photoCount`, `description`, `hasPublishedPricing`** | **0.0%** |

Split: 200 vendors / 50 venues, spread across **18 states**. **The headline that could mislead
you: the real-events source is a contact product, not a capacity product.** If you need capacity,
use the venue directory.

Every run prints its own measured fill in the log, on the run you actually paid for.

***

### How to run it

#### Paste a URL (the fastest way)

Run the search on partyslate.com, copy the address bar, paste it in. Start URLs override every
other picker, and you can mix all three shapes in one run:

```json
{
  "startUrls": [
    "https://www.partyslate.com/find-venues/near/chicago-il-usa/types/ballroom",
    "https://www.partyslate.com/find-vendors/wedding-photographer/area/new-york-city",
    "https://www.partyslate.com/real-events/weddings"
  ],
  "maxItems": 45
}
```

The three supported shapes — the only ones PartySlate itself publishes, taken from its own
sitemap (2,559 `/find-vendors`, 409 `/find-venues` and 66 `/real-events` pages):

```text
/find-venues/near/<place>                        e.g. /find-venues/near/chicago
/find-venues/near/<place>/types/<venueType>           /find-venues/near/chicago-il-usa/types/ballroom
/find-venues/<eventType>-venues/near/<place>          /find-venues/wedding-venues/near/los-angeles
/find-vendors/<segment>/area/<metro>                  /find-vendors/wedding-photographer/area/new-york-city
                                                      /find-vendors/event-vendors/area/albany  (all categories)
/real-events/<category>[?area=<metro>]                /real-events/mitzvahs?area=miami
```

`<place>` works as a PartySlate metro slug (`chicago`) or a Google place slug
(`chicago-il-usa`) — both resolve. A company profile URL (`/venues/<slug>`, `/vendors/<slug>`) is
**not** a search page and is rejected rather than half-scraped. Anything unrecognised stops the
run immediately with PartySlate's live vocabulary printed.

#### Venues in one metro

```json
{ "listingType": "venues", "locations": ["miami"], "venueTypes": ["ballroom", "hotel"], "minCapacity": 300, "maxItems": 200 }
```

#### Vendors, filtered by category and ownership

```json
{ "listingType": "vendors", "locations": ["new-york-city"], "vendorCategories": ["caterer", "planner"], "diversityClassifications": ["woman-owned"], "maxItems": 200 }
```

`vendorCategories`, `venueTypes`, `diversityClassifications` and `withPublishedPricingOnly` are
all **server-side** — they narrow the pool without costing you extra requests.

#### Every pro credited on published events

```json
{ "listingType": "real-events", "eventCategories": ["weddings", "corporate-events"], "maxItems": 250 }
```

Categories are interleaved so a capped run is not all weddings. Leave `enrichContacts` on here —
a credit line carries almost nothing without it.

#### Nationwide

```json
{ "listingType": "both", "locations": [], "maxItems": 1000 }
```

An empty `locations` sweeps all 119 metros breadth-first over a deterministic scatter, so a
500-row nationwide run came back across **14 metros in 21 states** (Fargo, Napa Valley, Phoenix,
San Francisco, Washington DC, Indianapolis, Baltimore…), not the first few alphabetically.
Multiple `locations` are interleaved the same way — 40 rows over Miami and Los Angeles returns
21/19, not 40/0.

#### The cheap sweep

```json
{ "listingType": "venues", "locations": [], "enrichContacts": false, "includeDescription": false, "maxItems": 5000 }
```

Turning `enrichContacts` off removes one ~0.5 KB request per company — roughly **half the
requests in the run**. You keep name, capacity, event spaces, address, phone and pricing; you lose
`website`, `instagramUrl` and `googlePlaceId`. **The price per company is the same either way** —
this only buys you speed.

#### Resume across runs

```json
{ "listingType": "venues", "locations": ["chicago"], "skip": 100, "maxItems": 100 }
```

PartySlate's search order is stable, so `skip` continues where the last run stopped instead of
re-buying the same leads. Skipped rows are never charged.

***

### Sample row — venue (directory)

```jsonc
{
  "listingType": "venue",
  "companyId": 1041,
  "name": "Builders BLDG",
  "profileUrl": "https://www.partyslate.com/venues/builders-bldg",
  "category": "Venue",
  "venueTypes": ["Ballroom", "Landmark", "Event Space", "Historic Space", "Meeting Space", "Outdoor"],
  "amenities": ["A/V Equipment", "Handicap Accessible", "Pet Friendly", "WiFi", "Windows", "Dance Floor", "Valet Parking", "Street Parking", "Coat Check"],

  "street": "222 N La Salle St",
  "city": "Chicago",
  "state": "Illinois",
  "stateCode": "IL",
  "postalCode": "60601",
  "address": "222 N La Salle St, Chicago, IL 60601, USA",
  "latitude": 41.8865777,
  "longitude": -87.6327762,
  "googlePlaceId": "ChIJ5UMWuLAsDogRGeJfwjncV34",

  "phone": "+13127267777",
  "phoneFormatted": "(312) 726-7777",
  "website": "http://buildersbldg.com/",
  "instagramUrl": "https://www.instagram.com/buildersbldg/",

  "seatedCapacity": 250,
  "standingCapacity": 700,
  "maxCapacity": 700,
  "eventSpaceCount": 4,
  "eventSpaces": [
    { "name": "Main Ballroom", "seatedCapacity": 150, "standingCapacity": 200,
      "types": ["Landmark", "Event Space", "Historic Space", "Meeting Space"],
      "amenities": ["WiFi", "Valet Parking", "Handicap Accessible", "Street Parking", "A/V Equipment", "Coat Check", "Windows", "Dance Floor", "Pet Friendly"],
      "photoCount": 81 }
  ],

  "photoCount": 84,
  "publishedEventCount": 33,
  "testimonialCount": 5,
  "responseTime": "12-24 hrs",
  "minimumSpendUsd": 25000,
  "pricePerGuestUsd": 280,
  "hasPublishedPricing": true,
  "topEventTypes": [
    { "eventType": "wedding", "publishedEvents": 22 },
    { "eventType": "corporate-event", "publishedEvents": 4 },
    { "eventType": "gala", "publishedEvents": 2 }
  ],

  "isUnclaimed": false,
  "isClosed": false,
  "closedAt": null,
  "profilePlan": "platinum",
  "description": "Host Unforgettable Events at Builders BLDG — A Landmark Chicago Venue …",
  "coverImageUrl": "https://img.partyslate.com/companies-cover-image/61157/image-a5a13f79-….jpg?tr=w-1200",
  "searchLocation": "chicago",
  "scrapedAt": "2026-08-12T21:22:57.621Z"
}
```

- `pricePerGuestUsd` is a **dollar amount per guest**, not a percentage and not a rating.
- `photoCount: null` on a venue means "PartySlate published no event spaces", not "no photos".
- `hasPublishedPricing: false` means the company never entered a price — 15.7% nationwide do.

### Sample row — vendor (directory)

```jsonc
{
  "listingType": "vendor",
  "companyId": 5013,
  "name": "Marcia Selden Catering & Events",
  "profileUrl": "https://www.partyslate.com/vendors/marcia-selden-catering-events",
  "category": "Caterer",
  "categorySlug": "caterer",
  "services": ["Bar Services & Beverages", "Servers"],

  "city": "New York",
  "state": "New York",
  "stateCode": "NY",
  "address": "New York, NY, USA",
  "latitude": 40.7127753,
  "longitude": -74.0059728,

  "phone": "+12033538000",
  "phoneFormatted": "(203) 353-8000",
  "website": "http://marciaselden.com/",
  "instagramUrl": "https://www.instagram.com/marciaseldencatering/",

  "photoCount": 3327,
  "publishedEventCount": 63,
  "albumCount": 70,
  "testimonialCount": 15,
  "responseTime": "12-24 hrs",
  "diversityClassifications": ["Woman Owned", "Hispanic or Latinx Owned"],
  "topEventTypes": [
    { "eventType": "wedding", "publishedEvents": 19 },
    { "eventType": "milestone-birthday", "publishedEvents": 12 },
    { "eventType": "bat-mitzvah", "publishedEvents": 5 }
  ],

  "isUnclaimed": false,
  "profilePlan": "platinum",
  "searchLocation": "new-york-city",
  "scrapedAt": "2026-08-12T21:22:57.621Z"
}
```

### Sample row — real-event credit

Trimmed to the fields that are populated on this source; the rest of the columns are present and
`null` (see table D for exactly which).

```jsonc
{
  "listingType": "venue",
  "companyId": 31079,
  "name": "The Boca Raton",
  "profileUrl": "https://www.partyslate.com/venues/the-boca-raton",
  "category": "Venue",

  "creditedService": "Venue",     // the role the event's author credited them for
  "sourceEventId": 43307,         // the published event this credit came from

  "street": "501 E Camino Real",
  "city": "Boca Raton",
  "state": "Florida",
  "stateCode": "FL",
  "postalCode": "33432",
  "address": "501 E Camino Real, Boca Raton, FL 33432, USA",
  "latitude": 26.3426656,
  "longitude": -80.0781121,
  "googlePlaceId": "ChIJ7-hEUxbi2IgRe9Z3PfCWArk",

  "phone": "+15614473251",
  "phoneFormatted": "(561) 447-3251",
  "website": "https://www.thebocaraton.com/weddings/",
  "instagramUrl": "https://www.instagram.com/thebocaraton",

  "publishedEventCount": 25,
  "maxCapacity": null,            // credit rows carry no capacity — measured 0.0% on 250 rows
  "isUnclaimed": false,
  "searchLocation": "miami",
  "scrapedAt": "2026-08-13T01:51:15.901Z"
}
```

- `creditedService` is **free text written by the event's author**, so it does not always match
  `category`: "Photography", "Photographer", "Florals", "Design & Floral" and "Decor" all occur.
  `category` is PartySlate's own taxonomy — sort on that.
- The same company credited on two events appears **once**, on the first event that reached it.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `startUrls` | array | `[]` | Paste PartySlate `/find-venues`, `/find-vendors` or `/real-events` URLs. **Overrides every field below in sections 1–3.** Validated in the form against the host and path. |
| `listingType` | select | `venues` | `venues` · `vendors` · `both` · `real-events` |
| `locations` | array | `["chicago"]` | Metro slugs or plain city names. **Empty = all 119 metros.** Ignored on the real-events source. |
| `eventCategories` | select\[] | all 6 | Which real-event categories to walk. Real-events source only. |
| `vendorCategories` | select\[] | all 15 | Vendor category filter — server-side, free. Vendors only. |
| `venueTypes` | select\[] | all 34 | Venue space-type filter — server-side, free. Note only 55.0% of venues have any type on file. Venues only. |
| `eventType` | select | none | **Re-ranks** results for that event type; it does not filter (see §6). |
| `diversityClassifications` | select\[] | none | Woman / Black / Veteran / LGBTQ+ owned etc. 20.8% of vendors declare one. Server-side. |
| `minCapacity` | number | `0` | Drop venues under this seated-or-standing capacity. Ignored on the real-events source. |
| `withPublishedPricingOnly` | checkbox | `false` | Server-side; costs nothing extra. Cuts the pool ~5:1. |
| `claimedOnly` | checkbox | `false` | Only companies that manage their own listing. |
| `withPhoneOnly` | checkbox | `false` | Applied **before** the contact lookup on directory sources, so it also makes the run cheaper. |
| `withWebsiteOnly` | checkbox | `false` | Applied **after** the contact lookup; the run fetches ~2× the candidates to compensate. You are still only billed for rows delivered. |
| `enrichContacts` | checkbox | `true` | The extra ~0.5 KB lookup that supplies website, Instagram, Google Place ID and venue city/state. Off → those come back empty. Same price either way. |
| `includeEventSpaces` | checkbox | `false` | Add the per-room breakdown to venue rows. |
| `includeDescription` | checkbox | `true` | Keep the (long) profile description. |
| `maxItems` | number | `100` | Rows to return — **your cost cap**. 100 = $0.40. |
| `skip` | number | `0` | Resume where the last run stopped instead of re-buying the same leads. |
| `maxConcurrency` | number | `5` | 5 measured at 24–34 req/s with zero failures. |
| `proxyConfiguration` | proxy | off | Not needed — see the ladder below. |

#### Reference: the 119 metro slugs

`albany` `albuquerque` `anchorage` `atlanta` `austin` `baltimore` `birmingham` `boise` `boston`
`bowling-green` `bozeman` `buffalo` `burlington` `cape-cod` `cedar-rapids` `central-jersey`
`charleston` `charleston-wv` `charlotte` `cheyenne` `chicago` `chicago-suburbs` `cincinnati`
`cleveland` `columbia` `columbus` `columbus-ga` `concord` `dallas` `denver` `des-moines`
`detroit` `el-paso` `eugene` `fargo` `finger-lakes` `florida-keys` `fresno` `grand-rapids`
`green-bay` `hampton-roads` `hamptons` `hartford` `hawaii` `hilton-head` `houston` `hudson-valley`
`indianapolis` `inland-empire` `jachsonville` `jackson` `jersey-shore` `kansas-city` `knoxville`
`lancaster` `las-vegas` `little-rock` `long-island` `los-angeles` `louisville` `madison` `memphis`
`mexico` `miami` `milwaukee` `minneapolis` `monterey` `montgomery` `napa-valley` `naples`
`nashville` `new-orleans` `new-york-city` `north-jersey` `oklahoma-city` `omaha` `orange-county`
`orlando` `outer-banks` `panhandle` `philadelphia` `phoenix` `pittsburgh` `portland` `portland-me`
`providence` `raleigh` `rapid-city` `reno` `richmond` `sacramento` `salt-lake-city` `san-antonio`
`san-diego` `san-francisco` `santa-barbara` `savannah` `scranton` `seattle` `shreveport`
`sioux-falls` `south-bend` `south-jersey` `spokane` `springfield-il` `springfield-ma`
`springfield-mo` `st-louis` `syracuse` `tallahassee` `tampa` `toledo` `topeka` `tucson` `tulsa`
`washington-d-c` `wichita` `wilmington` `wilmington-de`

Watch the spellings: New York City is `new-york-city`, Washington is `washington-d-c`, and
Jacksonville is misspelt **`jachsonville`** in PartySlate's own data. You do not have to memorise
any of them — type `"New York"` or `"Washington DC"` and it is resolved through PartySlate's
geocoder, with the run log printing exactly what it resolved to.

#### Reference: the 34 venue types

`event-space` `meeting-space` `hotel` `outdoor` `ballroom` `restaurant` `historic-space` `bar`
`garden` `waterfront` `country-club` `museum` `venue-with-activities` `landmark` `resort` `estate`
`theater` `mansion` `barn` `rooftop` `art-gallery` `winery` `vineyard` `farm` `brewery`
`distillery` `loft` `ranch` `boat` `beach` `park` `tent` `retail-space` `convention-center`

#### Reference: the 15 vendor categories and 6 event categories

Vendors, with nationwide counts: **Event Planner** (7,104) · **Photographer** (4,939) ·
**Design & Floral** (3,922) · **Entertainment** (3,497) · **Caterer** (3,098) · Rentals (1,841) ·
Bakery & Desserts (894) · Videographer (724) · Invitations & Print (688) · Parking &
Transportation (668) · Hair, Makeup & Stylist (640) · AV & Technology (508) · Event Agency (441) ·
Favors & Gifts (394) · Staffing (250).

Real events, with live event counts: **Weddings** (25,053) · **Corporate Events** (8,988) ·
Celebrations (3,841) · Birthdays (2,438) · Mitzvahs (2,272) · Fundraisers (2,001) = **44,593**.

***

### Pricing

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

| Run | Companies | Cost |
|---|---:|---:|
| The shipped default (100 Chicago venues) | 100 | **$0.40** |
| One metro's venues, end to end (Chicago) | 1,279 | **$5.12** |
| One metro's vendors, end to end (Chicago) | 1,916 | **$7.66** |
| Every venue in the country | 18,992 | **$75.97** |
| The entire directory, venues + vendors | 48,600 | **$194.40** |

You are charged for **rows delivered**, never for a company that was fetched and then removed by
your filters, and never twice for the same company — duplicates are dropped on the PartySlate slug
before anything is fetched. Rows are charged as they are pushed, so if you hit a budget cap you
get whole rows and stop, not a half-billed dataset. `maxItems` is your hard cost cap.

The extra contact lookup, the retries and the (unused) proxy budget are ours, not yours: a run
that fetches 400 companies to deliver 200 bills you for 200.

***

### Limits, honestly

- **No email addresses.** There is no `email` column in this dataset. PartySlate's venue and
  vendor profiles do not carry one, and this Actor will not guess one from a domain. `website`
  (86.7% / 79.0% on a whole-metro walk, **96.4%** on the real-events source) plus `phone` (83.4% /
  66.4%, **88.4%** on real events) is the handle to enrich from. If you want the email step done
  for you, our `eventective-scraper` crawls each vendor's own website for one (~50% yield in its
  own testing) on a different directory.
- **No ratings or review scores.** PartySlate publishes written testimonials, not a star rating,
  so you get `testimonialCount` and not a score. A rating column here would be invented.
- **Real-event rows have 0.0% capacity, event spaces, photo counts, description and pricing** —
  measured on 250 rows. That is what a credit line is. Use the venue directory for structure and
  the real-events source for contacts.
- **Vendor street addresses are rare** (8.5%) — city-level only for most. `latitude`/`longitude`
  are still 100%, but they are the city centroid, not the front door.
- **`photoCount` means different things on venue and vendor rows** — see §2. Never chart the two
  in one column.
- **The listing is what the company chose to publish.** Capacity, pricing, years in business and
  amenities are self-reported and blank on the listings that never filled them in; the fill tables
  above tell you exactly how often. A missing capacity is a PartySlate data gap, not a scrape
  failure — the same response comes back off-proxy and from a browser.
- **`pricePerGuestUsd` / `minimumSpendUsd` are PartySlate's published figures**, verified against
  the venue's own profile page, but they are a starting point for a quote, not a quote.
- **US-centric.** PartySlate's taxonomy carries 119 metros, of which one (`mexico`) is outside
  the US. There is no European or APAC coverage to be had here.
- **Cross-run dedupe is your job.** Runs deduplicate by company slug **within** a run. Across
  runs, use `skip`, or dedupe on `slug`.
- **No login, no API key, no CAPTCHA-solving service, and no attempt to reach anything behind
  an account.** Company profile URLs are rejected rather than half-scraped into a thin row.

***

### How it works

PartySlate's own public JSON API — the same calls its `/find-venues`, `/find-vendors` and
`/real-events` pages make in your browser. **No login, no cookie, no token, no browser, no
proxy.**

1. `GET /api/categorical_options` — the live taxonomy (119 metros, 15 vendor categories, 34 venue
   types, 6 event categories, 37 event types, amenities, ownership classifications). Read at run
   time, so a market PartySlate adds tomorrow works without a code change.
2. `GET /api/find-venues?place_slug=…&page=N` / `GET /api/find-vendors?location=…&page=N` —
   20 records per request, with the page count returned up front.
3. `GET /api/real-events?event_category=…&page=N` → `GET /api/events/{id}` — 21 events per page,
   then that event's credit list.
4. `GET /api/companies/{slug}` — ~0.5 KB per company, for website, Instagram, Google Place ID and
   real city/state fields.

The HTML profile pages carry the same data in a client-side payload, but at ~50 KB gzipped each
versus 0.5 KB for the JSON. Using the API is the same data 100× cheaper — which is why this is
priced at $0.004/company.

#### Transport ladder

Measured through Apify, retries off, concurrency 5. The home-broadband result is not a rung and
is not reported here — no Apify container has a residential IP.

| Rung | Result |
|---|---|
| **direct, no proxy** | **3,115 / 3,115 = 100.0%** @ 24.0 req/s over a 130 s nationwide sweep |
| direct, 50 random companies from the whole corpus | 50 / 50 = 100.0% @ 34.1 req/s |
| Apify Proxy, datacenter | 39 / 40 = 97.5% @ 2.7 req/s (the miss was a proxy `ECONNREFUSED`) |
| Apify Proxy, RESIDENTIAL, fresh session | 40 / 40 = 100.0% @ 1.1 req/s |
| Apify Proxy, RESIDENTIAL, pinned session | 40 / 40 = 100.0% @ 2.4 req/s |

No 403, no CAPTCHA, no challenge at any rung, and no 429 at these volumes. **PartySlate is not
walled, so a proxy only adds a failure mode and a bill** — the default is off, and that is a cost
win as well as a reliability one. Past roughly 3,000-4,000 companies in a single run one IP does
get volume-throttled; that is a rate limit, not a wall, and it is handled — see the throttle note
in the FAQ.

#### Uniqueness

Contiguous page walks with uniqueness asserted in-run — sparse offsets cannot collide and would
have proved nothing:

| Walk | Pages | Rows | Unique | Dupe rate |
|---|---:|---:|---:|---:|
| venues, Chicago | 1–64 | 1,279 | 1,279 | **0.00%** |
| venues, Austin | 1–13 | 249 | 249 | **0.00%** |
| vendors, Chicago | 1–96 | 1,916 | 1,916 | **0.00%** |
| vendors, Austin | 1–19 | 366 | 366 | **0.00%** |
| real events, 6 categories | 100 events | 250 | 250 | **0.00%** |

Every directory walk's row count matched PartySlate's own reported total exactly. Two full
end-to-end runs (1,279 venues in 33 s, 1,916 vendors in 41 s) emitted zero duplicate slugs and
zero failed requests. Deduplication happens on the company slug **before** the contact lookup and
before billing, so the dataset — and your bill — never holds the same company twice. The same
company credited on two different real events is likewise emitted once.

#### When a run fails

It fails loudly instead of handing back a quiet empty dataset:

- **Zero rows throws**, with the number of pages searched, the queries run and how many rows your
  filters removed.
- **A metro that does not exist throws**, listing all 119 live slugs — it never silently returns
  nothing.
- **A start URL that is not a PartySlate search page throws** before any request is billed, with
  the live vocabulary printed.
- **A shrunken taxonomy throws.** If `/api/categorical_options` returns fewer than 40 metros, the
  run refuses to sweep a partial slice of the directory and call it nationwide.
- **More than 25% failed search requests throws**, rather than passing off a partial crawl as a
  complete one. So does >25% failed event lookups, or >30% failed contact lookups.
- **Running out of matching companies is a warning, not a silent short run** — the log tells you
  how many you got against how many you asked for.

***

### Related Actors

| Actor | What it is | Why you would use it instead |
|---|---|---|
| [Tagvenue Scraper](https://apify.com/ScrapersDelight/tagvenue-scraper) | Event & party venue leads | Bookable hire spaces with UK/AU/US coverage — PartySlate is US-only |
| [Giggster Scraper](https://apify.com/ScrapersDelight/giggster-space-scraper) | Film, photo & event space leads | Hourly-rate production locations, with the host as the lead |
| [Eventective Scraper](https://apify.com/ScrapersDelight/eventective-scraper) | Event vendor & venue leads **+ emails** | When you need an email address, which PartySlate profiles do not carry |
| [The Bash Scraper](https://apify.com/ScrapersDelight/thebash-scraper) | DJs, bands, photographers | Entertainment supply specifically, with per-act pricing |
| [Roaming Hunger Scraper](https://apify.com/ScrapersDelight/roaminghunger-scraper) | Food-truck leads | Mobile catering, which PartySlate barely covers |
| [BounceGuide Scraper](https://apify.com/ScrapersDelight/bounceguide-scraper) | Bounce-house & party rental leads | The kids-party end of rentals |
| [Eventbrite Scraper](https://apify.com/ScrapersDelight/eventbrite-scraper) | Event leads by city & category | Ticketed events and organizers rather than the supply side |

Short version: **PartySlate is where you go for venue capacity and the pros credited on real
events; Eventective is where you go for email addresses.**

***

### FAQ

**Does this need an account, a login or an API key?**
No. It reads PartySlate's public JSON API, the same one your browser calls. No login, no cookie,
no token, no CAPTCHA-solving service.

**Can I get vendor or venue email addresses?**
Not from this Actor — there is no `email` column and nothing on this page implies one. A
PartySlate venue or vendor profile does not publish an email address, so an email column on a
"PartySlate" list did not come from the profile. What you get instead is `website` (up to 96.4%)
and `phone` (up to 88.4%), which is exactly what an enrichment step needs. If you want that step
done for you on a different directory, our `eventective-scraper` crawls each vendor's own website
for an email (~50% yield in its own testing).

**Will a run ever succeed with zero rows?**
No. A zero-row run throws with the scope, the request counts and how many rows your filters
removed. A green-but-empty dataset is treated as a bug, not an outcome.

**Two runs — will I get duplicates?**
Not within a run: dedupe happens on the company slug before the contact lookup and before
billing, measured at 0.00% across the 4,060 rows of contiguous walks below. Across runs, set `skip` to where
the last run stopped, or dedupe on `slug` yourself.

**Do I get charged for rows my filters throw away?**
No. You are billed per company **returned**. A narrow filter costs you time and the Actor its
request budget — not your money.

**Can I get the whole catalogue in one run?**
Yes: set `listingType` to `both`, leave `locations` empty and set `maxItems` to `48600`. That is
$194.40 at the published rate, and roughly 30–45 minutes at the measured 20–30 companies/second.
Most buyers run one metro at a time.

**My run returned fewer rows than `maxItems`.**
You ran out of matching companies — the log says so explicitly, with the count. Chicago has 1,279
venues; asking for 5,000 in Chicago returns 1,279. Add metros, or leave `locations` empty.

**Why are capacity and pricing null on so many rows?**
Because the company never filled them in. 78.9% of venues publish a capacity and 15.7% publish
pricing, nationwide. That is a PartySlate data-completeness gap, not a scraping failure — the same
response comes back off-proxy and from a browser.

**Does it need a proxy?**
Not for a normal run, and it is off by default. Direct answered 3,115 of 3,115 requests at 24 req/s;
an Apify datacenter proxy did worse (39/40, at 2.7 req/s).

**One caveat, measured 2026-08-18 and worth knowing before you queue a very large job:** PartySlate
*does* throttle a single IP at high volume. About 4,500 requests from one address inside a few
minutes returned a sustained **HTTP 429 with `Retry-After: 300`** on every endpoint for the full
five minutes. In round numbers that is roughly 3,000-4,000 companies in one run before the limit
bites. When it happens this Actor does **not** fail. If the run has enough time left, it waits out
the `Retry-After` PartySlate asks for and carries on where it stopped (measured 2026-08-19: a
throttled 300-company request waited the 300 s and then returned all 300 rows). If a whole wait
plus one more attempt would not fit inside the run's timeout, it stops politely instead: it keeps
and pushes every company it has already collected and enriched, charges for exactly those, and
sets a status message telling you the number to put in **Skip** to continue. If you want one
uninterrupted very large run, either
lower **Concurrency**, split it across runs with **Skip**, or turn the **Proxy** input on so the
requests do not all come from one address.

**What is `creditedService` and why doesn't it match `category`?**
`creditedService` is free text written by the event's author ("Photography", "Florals", "Decor").
`category` is PartySlate's own 15-value taxonomy. Group and sort on `category`.

**Can I filter by event type — wedding vendors only?**
Not as a hard filter, and this Actor will not pretend otherwise: PartySlate's event-type parameter
re-ranks the same pool rather than shrinking it (406 New York photographers either way). Set it to
put wedding-first companies at the top of a capped run.

**Can I scrape one specific venue's profile page?**
No — a `/venues/<slug>` URL is a profile, not a search page, and it is rejected rather than
half-scraped into a thin row. Search the metro it is in and filter the dataset.

**How do I schedule this without re-buying the same leads?**
Use Apify Schedules with `skip` advancing by your `maxItems` each run, or schedule the same
narrow search and dedupe on `slug` downstream.

**Where does the field-fill number in my run come from?**
Every run prints its own measured fill at the end of the log, on the rows you actually paid for.
The tables above are from earlier full-corpus runs, stated with their sample sizes.

***

### Legal & fair use

This Actor reads pages and public JSON endpoints that PartySlate serves to any visitor without
authentication. PartySlate's `robots.txt` sets `Allow: /` for general user agents and its only
`Disallow` rules target photo-viewer query strings for two named crawlers — none of the paths
this Actor reads are disallowed. It does not log in, does not solve CAPTCHAs, does not use a
CAPTCHA-solving service, and collects nothing behind any authentication.

Rows describe **businesses**, but a small business's public contact details can still constitute
personal data in some jurisdictions. You are responsible for complying with PartySlate's terms and
with how you use the data — including GDPR/CCPA where it applies, and CAN-SPAM, CASL or PECR for
any outreach.

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

***

### Feedback

Found a missing field, want a new filter, or spotted a number on this page that no longer matches
a run? Open an issue on the **Issues** tab.

# Actor input Schema

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

Run the search you want on partyslate.com, copy the address bar, paste it here. Three shapes work, and you can mix them:

• https://www.partyslate.com/find-venues/near/chicago  (also /near/chicago-il-usa, and /near/<place>/types/ballroom)
• https://www.partyslate.com/find-vendors/wedding-photographer/area/new-york-city
• https://www.partyslate.com/real-events/weddings  (every pro credited on published events)

A company profile URL (/venues/<slug>, /vendors/<slug>) is NOT a search page and is rejected rather than half-scraped. Anything else fails immediately with PartySlate's live vocabulary printed, so you never get a green run with an empty dataset. Leave empty to use the pickers below.

## `listingType` (type: `string`):

Venues are event spaces (18,992 on PartySlate); vendors are the event businesses around them — planners, photographers, caterers, florists, DJs, rentals and 9 more categories (29,608). "Both" returns them in one dataset with identical columns and a listingType flag on every row. "Real events" is a different route to the same companies: it walks PartySlate's 44,593 published real events and returns every pro credited on them — including venues and pros that never appear in the directory search. Real-event rows are thinner (no capacity, no published pricing, no photo counts) — see the README's fill table D.

## `locations` (type: `array`):

PartySlate metro slugs — chicago, new-york-city, los-angeles, miami, dallas, atlanta, austin, houston, boston, san-francisco, seattle, denver, nashville, las-vegas, orlando, phoenix, washington-d-c, philadelphia … 119 in all (the README lists every one). Or just type a plain city name — "New York", "Washington DC" — and it is resolved through PartySlate's own geocoder, with the run log printing exactly what it resolved to. A slug that matches nothing stops the run with the full live list rather than returning zero rows. LEAVE EMPTY to sweep all 119 metros: the sweep is breadth-first, so a 500-row nationwide run came back across 14 metros in 21 states, not all-Albany. Ignored when the source is Real events.

## `eventCategories` (type: `array`):

Which slices of PartySlate's published-event gallery to walk. Empty = all six. Live event counts: Weddings 25,053 · Corporate Events 8,988 · Celebrations 3,841 · Birthdays 2,438 · Mitzvahs 2,272 · Fundraisers 2,001. Categories are interleaved, so a capped run is not all weddings. Ignored unless the source is Real events.

## `vendorCategories` (type: `array`):

Limit vendors to these categories. Empty = all 15. Nationwide counts: Event Planner 7,104 · Photographer 4,939 · Design & Floral 3,922 · Entertainment 3,497 · Caterer 3,098 · Rentals 1,841 · Bakery & Desserts 894 · Videographer 724 · Invitations & Print 688 · Parking & Transportation 668 · Hair, Makeup & Stylist 640 · AV & Technology 508 · Event Agency 441 · Favors & Gifts 394 · Staffing 250. This is a server-side filter, so it costs nothing extra. Ignored when you scrape venues.

## `venueTypes` (type: `array`):

Limit venues to these space types. Empty = all 34. Most common nationwide: Event Space 11,373 · Meeting Space 6,470 · Hotel 6,243 · Outdoor 5,846 · Ballroom 5,384 · Restaurant 4,884 · Historic Space 3,470 · Bar 1,868 · Garden 1,687 · Waterfront 1,643 · Country Club 1,548 · Museum 1,522. Server-side, so it costs nothing extra — but only 55.0% of venues have ANY space type on file, so a type filter also discards every venue that never filled its spaces in. Ignored when you scrape vendors.

## `eventType` (type: `string`):

PartySlate's event-type parameter is a RANKING signal, not a filter — measured: New York photographers return 406 matches with or without it, and Los Angeles returns 1,214 venues either way; only the ORDER changes. So on a capped run this decides WHICH wedding-first or corporate-first companies you get, and on an uncapped run it changes nothing but the sequence. Applies to both venues and vendors.

## `diversityClassifications` (type: `array`):

Keep only vendors that self-declare one of these ownership classifications on PartySlate. 20.8% of vendors declare at least one, so expect this to remove about four rows in five. Server-side, so it costs nothing extra. Empty = no filter.

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

Drop venues whose largest published capacity (seated or standing) is below this. Only 78.9% of venues publish any capacity, and every venue without one is dropped when you set a floor. Vendor rows are unaffected — vendors have no capacity — so a "Both" run keeps them. Not available on the Real events source, which carries no capacity at all; it is ignored there with a warning in the log. 0 = keep everyone.

## `withPublishedPricingOnly` (type: `boolean`):

Ask PartySlate for only the companies that publish a minimum spend or per-guest price — 15.7% of venues nationwide, 20.0% of vendors in a whole-metro walk, so this cuts the pool by roughly five to one. Server-side, so it costs nothing extra. Ignored on the Real events source.

## `claimedOnly` (type: `boolean`):

Keep only companies that have claimed their PartySlate profile — a live account rather than a directory stub. 67.5% of venues and 83.5% of vendors in a whole-metro walk are claimed. Claimed listings are far likelier to carry a phone, photos and a real description.

## `withPhoneOnly` (type: `boolean`):

Keep only companies with a public phone number (80.9% of venues, 60.3% of vendors nationwide). On the directory sources it is applied BEFORE the website lookup, so it also makes the run cheaper; on the Real events source the phone only exists after that lookup, so it is applied afterwards instead and the run fetches spare candidates to compensate.

## `withWebsiteOnly` (type: `boolean`):

Keep only companies with a public website (86.7% of venues, 79.0% of vendors in a whole-metro walk). A website is only known AFTER the contact lookup, so this filter discards already-fetched rows — the run collects roughly twice as many candidates to compensate. You are still billed only for rows delivered. Requires "Look up website, Instagram and city/state" to stay on.

## `enrichContacts` (type: `boolean`):

Fetch each company's public profile record for its website, Instagram, Google Place ID and — on venue and real-event rows — real city and state fields. One extra ~0.5 KB request per company; it does not change the price. Turn it OFF for a fast structural sweep, but website, Instagram and Google Place ID then come back empty. Leave it ON for the Real events source: a credit line carries almost nothing without it.

## `includeEventSpaces` (type: `boolean`):

Add an eventSpaces array to venue rows: every bookable room with its own name, seated and standing capacity, space types, amenities and photo count. Present on 60.9% of venues in a whole-metro walk. Off by default because it makes the CSV export wide and ragged. Directory venue rows only — real-event credit rows never carry it.

## `includeDescription` (type: `boolean`):

Keep the company's full self-written profile description (85.8% of venues, 75.3% of vendors in a whole-metro walk). It is often several hundred words — turn it off for a compact CSV.

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

How many companies to return, and therefore what the run costs: 100 = $0.40, 1,000 = $4.00, the whole 48,600-company directory = $194.40. Listings arrive 20 per request and each company costs one small extra lookup, so this is the runtime dial too (measured 20-30 companies/second). Rows are charged as they are pushed, so a budget cap stops you on a whole row.

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

Skip this many matching companies before collecting. Results follow PartySlate's own search order, which is stable, so set skip=100 on the next run to continue where a maxItems=100 run stopped instead of re-buying the same leads. Skipped rows are never charged.

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

Parallel requests. 5 was measured at 24-34 requests/second with zero failures across 3,115 live requests; there is no reason to go higher and PartySlate is a small site.

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

OPTIONAL — leave off for a normal run. PartySlate's public API answered 3,115 of 3,115 direct requests with no block and no CAPTCHA, and an Apify datacenter proxy did WORSE (39/40, and 2.7 req/s against 24). It DOES throttle a single IP at high volume, though: measured 2026-08-18, roughly 4,500 requests from one address inside a few minutes returns HTTP 429 with Retry-After 300 for five minutes — in round numbers about 3,000-4,000 companies in one run. The Actor stops politely at that point, keeps and charges for the rows it already has, and tells you the number to put in Skip to continue. Turn this on if you want one uninterrupted very large run, or if you are running from a network PartySlate blocks.

## Actor input object example

```json
{
  "startUrls": [],
  "listingType": "venues",
  "locations": [
    "chicago"
  ],
  "eventCategories": [],
  "vendorCategories": [],
  "venueTypes": [],
  "eventType": "",
  "diversityClassifications": [],
  "minCapacity": 0,
  "withPublishedPricingOnly": false,
  "claimedOnly": false,
  "withPhoneOnly": false,
  "withWebsiteOnly": false,
  "enrichContacts": true,
  "includeEventSpaces": false,
  "includeDescription": true,
  "maxItems": 100,
  "skip": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Name, category or venue type, city, state, capacity, event spaces, website, phone, Instagram, photo and event counts, published pricing and claimed status.

# 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 = {
    "listingType": "venues",
    "locations": [
        "chicago"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/partyslate-venue-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 = {
    "listingType": "venues",
    "locations": ["chicago"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/partyslate-venue-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 '{
  "listingType": "venues",
  "locations": [
    "chicago"
  ],
  "maxItems": 100
}' |
apify call scrapersdelight/partyslate-venue-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/partyslate-venue-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/3gGEIP9Hmj7GoDbXc/builds/EY3EsfobYdNHFfHkb/openapi.json