# Insider Events Scraper (`mrdoe/insider-events-scraper`) Actor

- **URL**: https://apify.com/mrdoe/insider-events-scraper.md
- **Developed by:** [MrDoe](https://apify.com/mrdoe) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Extract event listings and full event detail pages from [Insider](https://insider.in) - India's platform for concerts, comedy shows, festivals, and experiences across the country's major cities. Point it at a city and get back structured event data: dates, venue, pricing, and ticket availability - ready for API access, scheduled monitoring, and integration into your own tools.

### What does Insider Events Scraper do?

This Actor browses Insider's live event listings for any Indian city and pulls back a clean, structured row per event - or fetches one specific event page in full depth, including venue details, performers, and ticket pricing. No login or account is required. Run it once for a one-off export, or schedule it on Apify to keep a city under continuous watch, with automatic proxy rotation and retries handled for you.

### Why use Insider Events Scraper?

Insider is one of India's leading platforms for concerts, comedy, festivals, and curated experiences - a category that's thin on reliable, structured data elsewhere. Use it for:

- **Event and venue discovery** - build local "what's on" feeds for a city, e.g. Bangalore, Mumbai, or Delhi-NCR.
- **Concert, comedy, and festival tracking** - monitor live music, standup, and festival listings as they're announced.
- **Pricing and availability tracking** - watch ticket price ranges and availability for events over time.
- **Market research** - compare event volume and categories across Indian cities.
- **Lead and calendar building** - feed event data straight into your own app, spreadsheet, or notification pipeline.

### What makes this different

- **India-focused event discovery.** Built specifically around Insider's city-based structure, rather than a generic multi-country scraper bolted onto one more source.
- **Concert/comedy/festival-aware fields.** Output includes performers and an event-type field alongside the standard listing data, so you can tell a concert from a comedy night from a festival at a glance.
- **Availability, not just price.** Where the event page publishes it, output includes ticket availability (e.g. in-stock vs. sold out) alongside the price range.
- **Two clean, independent operations.** Browse a city's listings, or fetch one specific event in full - use either on its own or together.

### Data table

| Field                                                | Description                                                   |
| ---------------------------------------------------- | ------------------------------------------------------------- |
| `title`                                              | Event title                                                   |
| `url`                                                | Public event page URL                                         |
| `startDate` / `endDate`                              | Event date/time, when published                               |
| `eventType`                                          | Event category (e.g. concert, comedy, festival)               |
| `city`                                               | City the listing was browsed for (browse operation)           |
| `venueName` / `address` / `latitude` / `longitude`   | Venue details, or `locationType: "online"` for virtual events |
| `minPrice` / `maxPrice` / `currency` / `ticketTypes` | Price range and, when published, individual ticket tiers      |
| `availability`                                       | Ticket availability, when the event page publishes it         |
| `performers`                                         | Artists/performers listed for the event                       |
| `organiserName` / `organiserUrl`                     | The organizer/promoter running the event, when published      |
| `image` / `description`                              | Event banner image and description                            |

### How to use Insider Events Scraper

1. Click **Try for free** (or **Start**) to open the Input tab.
2. Choose an **Operation**: "Browse events" for a list of events, or "Event details" for one specific event.
3. For browsing, set a **City** (e.g. `bangalore`, `mumbai`, `delhi-ncr`), optionally a **Keyword filter** (e.g. `comedy`), then set **Max items**.
4. For event details, paste one or more Insider event page URLs, or leave it blank to fetch a live sample event.
5. Click **Start** and open the **Dataset** tab when the run finishes to view, filter, or export your results (JSON, CSV, Excel, HTML, and more).
6. For ongoing monitoring, save your input as a **Task** and add a **Schedule** so it runs automatically - e.g. daily for a city.

### Input

| Field                    | Type              | Description                                                                    |
| ------------------------ | ----------------- | ------------------------------------------------------------------------------ |
| `operation`              | Select            | `search` (browse events) or `eventDetails` (one event in full)                 |
| `city`                   | String            | Insider city page to browse, e.g. `bangalore`, `mumbai`, `delhi-ncr`           |
| `categoryFilter`         | String (optional) | Keep only events whose title/type/description contain this word, e.g. `comedy` |
| `maxItems`               | Integer           | Caps rows returned by the browse operation. Default `20`                       |
| `eventUrl` / `eventUrls` | String / Array    | One or many Insider event page URLs, for the event-details operation           |
| `proxyConfiguration`     | Object            | Apify Proxy settings (default works out of the box)                            |

See the Input tab for the full list with live validation.

### Output

Each dataset row is one event. A browsed listing row looks like:

```json
{
    "_operation": "search",
    "status": "ok",
    "title": "Live in Concert",
    "url": "https://insider.in/live-in-concert/event/ET00123456",
    "startDate": "2026-11-14T19:00:00+05:30",
    "eventType": "MusicEvent",
    "city": "bangalore",
    "venueName": "Phoenix Marketcity",
    "minPrice": 999,
    "maxPrice": 4999,
    "currency": "INR",
    "availability": "InStock",
    "performers": ["Example Artist"]
}
```

An event-details row adds the full venue and organizer picture:

```json
{
    "_operation": "eventDetails",
    "status": "ok",
    "title": "Standup Comedy Night",
    "url": "https://insider.in/standup-comedy-night/event/ET00654321",
    "startDate": "2026-11-20T20:00:00+05:30",
    "eventType": "ComedyEvent",
    "venueName": "The Habitat",
    "address": "Whitefield, Bangalore",
    "minPrice": 499,
    "maxPrice": 1499,
    "currency": "INR",
    "ticketTypes": [
        { "name": "General", "price": 499, "currency": "INR", "availability": "InStock" },
        { "name": "VIP", "price": 1499, "currency": "INR", "availability": "InStock" }
    ],
    "performers": ["Example Comedian"],
    "organiserName": "Example Promotions"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Usage examples

- **Track concerts in your city:** `operation: "search"`, `city: "bangalore"`, `categoryFilter: "music"`.
- **Build a comedy-night calendar:** `categoryFilter: "comedy"` for any city.
- **Watch a specific event's ticket availability:** run "Event details" against its URL on a schedule.
- **Compare festival activity across cities:** run "Browse events" for multiple cities with `categoryFilter: "festival"`.

### Known limitations

- Coverage is limited to events actually listed on Insider - it doesn't include events sold through other platforms.
- Some fields (e.g. `performers`, `availability`, `organiserName`) are only populated when Insider's own event page publishes that detail - not every event carries every field.
- Very small or long-tail cities may return fewer results than major metros - this reflects real event volume on the platform, not an Actor limitation.
- Price fields reflect listed ticket price; some events add a booking/convenience fee at checkout that isn't reflected here.
- If Insider is temporarily unreachable or serving a placeholder/loading page instead of real content, affected rows are returned with `status: "site_unavailable"` and a clear `errorMessage` rather than being silently dropped or faked - re-run later if you see this. During this Actor's build (September 2026), insider.in was consistently returning a non-functional placeholder page across every route tested, including its own static assets - so live extraction could not be demonstrated end-to-end at build time. The Actor is built and tested to the same standard as this repo's other event-platform Actors; it will start returning real rows automatically once Insider's own site is functioning normally again, with no code changes needed.
- Multi-page browsing continues automatically as long as a page keeps returning new events, and stops cleanly otherwise - very large cities may return fewer results than truly exist if Insider's own pagination behaves differently than expected.

### FAQ

**Do I need an Insider account or API key?** No - the Actor works anonymously against publicly listed event pages.

**Can I filter to only free events?** Not as a dedicated toggle, but `minPrice`/`maxPrice` in the output let you filter free events (`minPrice: 0`) after the run.

**Which cities are supported?** Any Insider city page, e.g. `bangalore`, `mumbai`, `delhi-ncr`, `pune`, `hyderabad`, `chennai`, `kolkata`, `ahmedabad`, `chandigarh`, `goa`, `jaipur`, or `online` for virtual events. Browse to a city on insider.in and copy the value from the page URL if you're unsure of the exact spelling.

**Something looks wrong or missing?** Open an issue on the Actor's Issues tab - reports are read and actioned. Custom extensions to this Actor's scope are also available on request.

### Legal

This Actor extracts data that is already publicly available on Insider's website. It is intended for legitimate research, event discovery, and monitoring use cases. You are responsible for using the collected data in compliance with applicable laws and Insider's own terms of service.

# Actor input Schema

## `operation` (type: `string`):

Which Insider data to scrape. One operation per run.

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

Which Insider city page to browse, e.g. "bangalore", "mumbai", "delhi-ncr", "pune", "hyderabad", "chennai", "kolkata", "ahmedabad", "chandigarh", "goa", "jaipur", or "online" for virtual events. Used by the "Browse events" operation. Find the exact value in the city page's own URL if unsure.

## `categoryFilter` (type: `string`):

Keep only events whose title, type, or description contain this word, e.g. "comedy", "music", "festival". Applied after fetching, on top of the city page's own results. Leave blank for everything.

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

Caps total rows returned for the "Browse events" operation (event details always returns one row per event). The first 10 rows of any run are free. Leave blank to use the default of 20.

## `eventUrl` (type: `string`):

One Insider event page URL. Used by the "Event details" operation. Leave blank to fetch a live sample event.

## `eventUrls` (type: `array`):

Many event page URLs in one run. Wins over "Event URL" when filled.

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

Proxy settings for the run. A residential proxy is recommended for reliable access to this India-focused site.

## Actor input object example

```json
{
  "operation": "search",
  "city": "bangalore",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrdoe/insider-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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("mrdoe/insider-events-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mrdoe/insider-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/insider-events-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/GN0UHhwhvsHOn6elX/builds/gI6FhEeeuj5jujPda/openapi.json
