# Posh.vip Events Scraper (`automation-lab/posh-vip-events-scraper`) Actor

Extract public Posh.vip events, ticket tiers, schedules, venues, coordinates, media, and organizer profiles from event, organizer, and city Explore URLs.

- **URL**: https://apify.com/automation-lab/posh-vip-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Posh.vip Events Scraper

Collect public Posh.vip event listings as structured records for calendars, ticket intelligence, venue research, and organizer outreach.

Paste a direct event URL, an organizer profile, or a supported city Explore URL. The Actor discovers matching events, opens each public event page through a stable residential session, enriches it with live ticket tiers, removes duplicates, and writes one normalized event per dataset item.

No Posh account, cookies, or private credentials are required.

### What does Posh.vip Events Scraper do?

The Actor combines Posh's public discovery, event, organizer, and ticket data into one integration-friendly record.

It can:

- extract one known event from a `/e/` URL;
- discover current events from a `/g/` organizer URL;
- discover city events from `/explore` URLs;
- paginate discovery up to `maxItems`;
- include live ticket prices, displayed fees, quantities, and availability;
- capture venue addresses and coordinates;
- capture organizer profiles, verification, bio, website, and Instagram;
- deduplicate events from overlapping inputs;
- retry Cloudflare blocks with bounded residential-session rotation.

The default dataset always contains event records. It does not mix organizer-only rows into the primary output.

### Who is it for?

#### Event aggregators and local calendars

Poll city feeds on a schedule, then upsert events by `eventId`. Use `startAtUtc`, `timezone`, venue fields, and the canonical URL to power calendar listings.

#### Ticket and venue intelligence teams

Track ticket tiers, base prices, displayed totals, quantities, availability, and sold-out signals across repeated runs.

#### Agencies and CRM teams

Use the nested `organizer` object to enrich venue and promoter records with public profile, website, Instagram, country, bio, and verification data.

#### Researchers and developers

Export normalized public event data to JSON, CSV, Excel, webhooks, databases, or another Actor without maintaining a protected-site scraper.

### Why use this Actor?

Posh's normal pages are protected by Cloudflare and often return HTTP 403 to datacenter clients. This Actor uses an HTTP-first implementation with sticky residential sessions and validated public structured responses.

That design avoids rendering a browser for every event while still returning the detail fields buyers need. It also fails loudly when Posh returns a challenge or an unrecognized response instead of treating a blocked page as an empty result.

### Supported Posh.vip URLs

| Input type | Example | Behavior |
| --- | --- | --- |
| Event | `https://posh.vip/e/just4fun-nyc-1` | Extracts that event directly |
| Organizer | `https://posh.vip/g/cafe-erzulie` | Finds current marketplace events whose organizer URL matches exactly |
| Explore root | `https://posh.vip/explore` | Uses Posh's New York City fallback |
| City Explore | `https://posh.vip/explore/miami` | Discovers events in the selected supported city |

Supported city slugs are New York City, Miami, Los Angeles, Washington DC, Boston, and Atlanta. The legacy `new-york-city` Explore slug is accepted even if Posh's current website redirects users through `/explore`.

Other hosts and unrelated Posh paths are rejected before network work begins.

### What data can you extract?

| Group | Fields |
| --- | --- |
| Identity | `eventId`, `name`, `url`, `shortUrl` |
| Schedule | `startAt`, `endAt`, `startAtUtc`, `endAtUtc`, `timezone`, `status` |
| Content | `description`, `shortDescription`, `imageUrl`, `galleryUrls`, `lineup` |
| Venue | `venueName`, `venueAddress`, `latitude`, `longitude` |
| Tickets | tier ID/name, price, total price, currency, quantity, purchase limit, availability, sale windows |
| Price summary | `lowestPrice`, `highestPrice`, `currency`, `isSoldOut` |
| Flags | RSVP, approval-only RSVP, password protection, draft status |
| Organizer | ID, name, URL, image, verified flag, bio, country, Instagram, website |
| Provenance | `sourceUrl`, `scrapedAt` |

Fields that Posh does not expose for a particular event are returned as `null` or an empty array. Ticket availability is a snapshot, not a reservation or guarantee of admission.

### Getting started

1. Open the Actor input tab.
2. Keep the prefilled New York City Explore URL or paste your own event, organizer, or supported city URL.
3. Choose the discovery date range and order.
4. Keep **Include live ticket tiers** enabled if price and availability matter.
5. Set `maxItems` to the maximum unique events you need.
6. Keep the prefilled Apify Residential Proxy configuration.
7. Click **Start**.
8. Open the **Events** dataset view or export it in your preferred format.

Start with one to ten events while testing a workflow, then increase the limit for production polling.

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | required | Public event, organizer, or Explore URLs |
| `maxItems` | integer | `10` | Maximum unique event records, from 1 to 10,000 |
| `when` | enum | `This Week` | Organizer/Explore range: Today, This Week, This Month, or Right Now |
| `sort` | enum | `Trending` | Organizer/Explore order: Trending, Newest, or Largest |
| `includeTickets` | boolean | `true` | Fetch live ticket details for every event |
| `maxConcurrency` | integer | `3` | Parallel event requests, from 1 to 10 |
| `proxyConfiguration` | object | Residential | Apify or custom proxy settings |

`when` and `sort` apply to discovery inputs. A direct event URL is always extracted because the user selected that exact source.

### Example inputs

#### Discover New York City events

```json
{
  "startUrls": [
    { "url": "https://posh.vip/explore/new-york-city?when=This+Week" }
  ],
  "when": "This Week",
  "sort": "Trending",
  "includeTickets": true,
  "maxItems": 20
}
```

#### Track one event

```json
{
  "startUrls": [
    { "url": "https://posh.vip/e/just4fun-nyc-1" }
  ],
  "includeTickets": true,
  "maxItems": 1,
  "maxConcurrency": 1
}
```

#### Poll an organizer and a city feed

```json
{
  "startUrls": [
    { "url": "https://posh.vip/g/cafe-erzulie" },
    { "url": "https://posh.vip/explore/miami" }
  ],
  "when": "This Month",
  "sort": "Newest",
  "includeTickets": true,
  "maxItems": 50
}
```

### Output example

The following shortened record reflects the current output shape from a real event test:

```json
{
  "eventId": "6a4585ba3bf29f19e8f99072",
  "url": "https://posh.vip/e/just4fun-nyc-1",
  "name": "Just4Fun NYC",
  "startAtUtc": "2026-07-26T02:00:00.000Z",
  "endAtUtc": "2026-07-26T08:00:00.000Z",
  "timezone": "America/New_York",
  "venueName": "Cafe Erzulie",
  "venueAddress": "894 Broadway, Brooklyn, NY 11206, USA",
  "latitude": 40.6978593,
  "longitude": -73.937206,
  "currency": "USD",
  "tickets": [
    {
      "id": "6a4585ba3bf29f19e8f99078",
      "name": "RSVP",
      "price": 0,
      "totalPrice": 0,
      "quantityAvailable": 2,
      "available": true
    }
  ],
  "lowestPrice": 0,
  "highestPrice": 110.67,
  "status": "ongoing",
  "organizer": {
    "id": "671bc97fb647481e9f965190",
    "name": "Cafe Erzulie",
    "url": "https://posh.vip/g/cafe-erzulie",
    "verified": true,
    "instagram": "https://www.instagram.com/cafe.erzulie",
    "website": "https://www.cafeerzulie.com/"
  },
  "scrapedAt": "2026-07-26T05:05:00.000Z"
}
```

Treat prices and quantities in this example as time-sensitive source data.

### How much does it cost to scrape Posh.vip events?

The Actor uses pay-per-event pricing:

- one `start` charge of **$0.005 per run**;
- one `item` charge for each event saved;
- no item charge for duplicates, rejected records, challenge pages, or failed events.

Current item tiers are:

| Tier | Price per saved event |
| --- | ---: |
| FREE | $0.0024563 |
| BRONZE | $0.0021359 |
| SILVER | $0.0016660 |
| GOLD | $0.0012815 |
| PLATINUM | $0.00085436 |
| DIAMOND | $0.00059806 |

At the FREE tier, 100 saved events cost about **$0.251** including one start charge. One thousand saved events cost about **$2.461**. Your exact tier is selected by Apify based on account usage.

Residential proxy and compute usage are covered by the Actor's pricing; users do not need to purchase a separate source API.

### Scheduling and change monitoring

For a recurring calendar or ticket-monitoring workflow:

1. Create one task per city or organizer group.
2. Use a stable `when` window such as This Week or This Month.
3. Schedule the task hourly or daily.
4. Upsert records by `eventId`.
5. Compare ticket arrays and `isSoldOut` with the previous snapshot.
6. Notify downstream systems only when relevant fields change.

Posh event IDs are more reliable deduplication keys than titles, which organizers can edit.

### Integrations and exports

Dataset results work with:

- JSON, JSONL, CSV, Excel, XML, and RSS exports;
- Apify webhooks for run completion;
- Google Sheets through Make or Zapier;
- PostgreSQL, BigQuery, Snowflake, or object storage;
- downstream Actors for enrichment and notification;
- custom applications through `apify-client`.

For CRM use, flatten the nested `organizer` object or preserve it as JSON according to your destination.

### Run from the Apify API

Replace `APIFY_TOKEN` with a secret environment variable. Do not hard-code it in public source.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~posh-vip-events-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://posh.vip/explore/miami"}],
    "when": "This Week",
    "maxItems": 25
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/posh-vip-events-scraper').call({
  startUrls: [{ url: 'https://posh.vip/explore/miami' }],
  when: 'This Week',
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/posh-vip-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://posh.vip/explore/miami'}],
    'when': 'This Week',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/posh-vip-events-scraper"
```

#### Claude Desktop

Add this JSON to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/posh-vip-events-scraper"
    }
  }
}
```

#### Cursor

Open Cursor's MCP settings and add the same `apify` server URL shown above.

#### VS Code

Add an HTTP MCP server named `apify` in your VS Code MCP configuration, using the same Actor-specific URL.

#### Example prompts

After connecting through MCP, try:

- “Run the Posh.vip Events Scraper for Miami events this week and return the ten cheapest.”
- “Extract this Posh event and summarize ticket availability by tier.”
- “Poll this organizer profile and format the events for a local calendar import.”

### Reliability, retries, and proxy behavior

Posh actively challenges direct datacenter traffic. Residential proxy routing is therefore part of the product, not an optional emergency fallback.

The Actor:

- keeps proxy identity stable within a request session;
- rotates after verified 403, 429, and transient 5xx responses;
- uses up to three bounded attempts;
- limits detail concurrency to ten;
- validates status and response shape;
- returns a failed run if every selected event is blocked or malformed.

Do not replace the default residential setting with direct access unless you have independently verified a compatible custom route.

### Limits and caveats

- Organizer discovery covers current events visible in Posh's public marketplace date windows.
- A valid organizer may return zero events when it has no public events in the selected range.
- Ticket prices and quantities can change immediately after a run.
- Hidden or password-protected event data is not bypassed.
- `isSoldOut` is derived from visible ticket tiers and can be `null` when tiers are unavailable.
- Posh can change internal response shapes; recognizable shape failures are surfaced in logs.
- Event descriptions are organizer-supplied and may contain inconsistent formatting.
- The Actor does not buy tickets, reserve inventory, sign in, or access attendee identities.

### Responsible use and legality

This Actor extracts information available on public Posh pages without a Posh login. Public availability does not remove your legal responsibilities.

Use the data only for lawful purposes. Respect applicable website terms, database rights, privacy rules, intellectual-property rights, and local regulations. Do not use organizer contact details for unlawful spam or harassment. Avoid republishing copyrighted descriptions or images beyond what your use case permits.

You are responsible for deciding whether your collection, retention, enrichment, and redistribution are lawful in your jurisdiction.

### Troubleshooting

#### Why did an organizer return zero records?

It may have no marketplace-visible events in the chosen range. Try `This Month`, verify the organizer URL, and inspect the Actor log for the discovery count.

#### Why did the run fail with a challenge error?

Confirm that the proxy input uses the Apify Residential group. Reduce `maxConcurrency` to one or two for a sensitive source. The Actor already rotates bounded sessions; repeated identical runs without a route change are not recommended.

#### Why are ticket fields empty?

Check that `includeTickets` is `true`. Some free, private, ended, or organizer-configured events expose no public ticket tiers.

#### Why is an event marked ended or ongoing?

Status is derived from Posh's UTC start/end values at scrape time. Keep `timezone` when displaying local event times.

#### How do I avoid duplicate calendar entries?

Upsert by `eventId`. The Actor removes duplicates within a run, but your destination must reconcile records across scheduled runs.

### Related Automation Lab Actors

- [Partiful Events Scraper](https://apify.com/automation-lab/partiful-events-scraper) for another social-event platform.
- [Luma Events Discovery Scraper](https://apify.com/automation-lab/luma-events-discovery-scraper) for Luma city and community event feeds.
- [Meetup Scraper](https://apify.com/automation-lab/meetup-scraper) for Meetup groups and events.

Use multiple event-platform Actors when building broader local calendars. Keep source-specific event IDs and URLs so records from different platforms remain traceable.

### FAQ

#### Does this Actor require a Posh account?

No. It uses public event and marketplace data only.

#### Can it scrape any city string?

Not through city Explore mode. It supports the city presets currently exposed by Posh: New York City, Miami, Los Angeles, Washington DC, Boston, and Atlanta. Direct event and organizer URLs are not restricted to those cities.

#### Does `maxItems` change the selected discovery scope?

No. It only caps the number of unique accepted events. Date and city filters remain unchanged.

#### Are unsuccessful events charged?

No item event is emitted for duplicates, rejected records, challenge pages, or failed event extraction. The one-time start event still applies once per run.

#### Can I turn off ticket requests?

Yes. Set `includeTickets` to `false` when you need event and organizer records without ticket-tier enrichment.

#### Is the output guaranteed to be complete?

No scraper can guarantee that a third-party site exposes every record continuously. The Actor returns marketplace-visible public data, validates response shapes, and reports failures rather than inventing missing values.

# Actor input Schema

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

One or more public Posh event (/e/), organizer (/g/), or Explore (/explore) URLs. Duplicate events are removed by event ID.

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

Maximum number of unique event records saved across all start URLs.

## `when` (type: `string`):

Date range used for organizer and Explore discovery. Direct event URLs are always extracted.

## `sort` (type: `string`):

Order used for organizer and Explore discovery.

## `includeTickets` (type: `boolean`):

Fetch live ticket prices, availability, sale windows, and limits for each event.

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

Number of event pages processed concurrently. Keep this conservative to reduce blocks.

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

Posh requires residential-quality routing. The default Apify Residential Proxy is recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://posh.vip/explore/new-york-city?when=This+Week"
    }
  ],
  "maxItems": 10,
  "when": "This Week",
  "sort": "Trending",
  "includeTickets": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the event overview view.

# 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 = {
    "startUrls": [
        {
            "url": "https://posh.vip/explore/new-york-city?when=This+Week"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/posh-vip-events-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 = {
    "startUrls": [{ "url": "https://posh.vip/explore/new-york-city?when=This+Week" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/posh-vip-events-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://posh.vip/explore/new-york-city?when=This+Week"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/posh-vip-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/cUbRKGm4Tju37KSZ4/builds/WX7M1t9ba0FA9XG7b/openapi.json