# Etix.com Ticket Availability Scraper (`scrapyspider/etix-ticket-availability-scraper`) Actor

Scrapes available seats from Etix.com event pages using the platform's internal seating chart API. Enter one or more event URLs and get all available seats with section, row, and seat label. Requires a Capsolver API key for AWS WAF bypass.

- **URL**: https://apify.com/scrapyspider/etix-ticket-availability-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Etix.com Ticket Availability Scraper

Scrapes available seats from Etix.com event pages — no account or cookies required — and returns structured JSON with section, row, seat label, and availability status for every open seat.

---

- No Etix account or login required
- Extracts all available seats by section and row in a single run
- Supports multiple event URLs per run — batch-check many events at once
- Uses Etix's internal seating chart API for accurate, real-time data
- AWS WAF CAPTCHA bypass via [Capsolver](https://capsolver.com) (capsolverApiKey input required)
- Built-in Apify residential proxy support for reliable scraping
- Optional SMTP email summary delivered after each run
- Outputs clean JSON ready to export as CSV or Excel

---

#### What data does it extract?

Each result in the dataset represents one available seat:

**Seat info:** seatLabel, seatId, status (`Available`)

**Location:** section, row

**Event:** eventUrl, eventId

**Meta:** scrapedAt (ISO 8601 timestamp)

Output format: JSON (exportable to CSV, Excel, XML via Apify dataset tools)

---

#### Use cases

- **Ticket arbitrage:** Monitor Etix events for newly released or returned seats and act fast
- **Event research:** Check seat availability across multiple events before purchasing
- **Venue analytics:** Analyze seating availability patterns by section and row
- **Alert automation:** Combine with Apify webhooks or email notification to get notified when seats open up
- **Market intelligence:** Track sell-out velocity for concerts and sporting events on Etix

---

#### How to use

1. Click **Try for free** above
2. In the **Input** tab, paste one or more Etix event page URLs (e.g. `https://www.etix.com/ticket/p/42269098/event-name`)
3. Leave **Proxy Configuration** as default (Apify residential proxy recommended)
4. Optionally configure **Email Notification** with your SMTP credentials to receive a results summary
5. Click **Start** and wait for the run to complete (typically under 2 minutes per event)
6. Download results as JSON, CSV, or Excel from the **Output** tab

---

#### Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `eventUrls` | Array of strings | **Yes** | One or more Etix event page URLs. Example: `https://www.etix.com/ticket/p/42269098/event-name` |
| `proxyConfiguration` | Object | No | Proxy settings. Defaults to Apify automatic residential proxy. Recommended to leave as default. |
| `capsolverApiKey` | String | No | **Required to run on Apify cloud.** Capsolver.com API key used to bypass AWS WAF CAPTCHA automatically. Get one free at [capsolver.com](https://capsolver.com). |
| `maxRetries` | Integer | No | Max retry attempts per URL if a request fails. Default: `3`. Range: 1–10. |
| `emailEnabled` | Boolean | No | Set to `true` to receive an email summary after the run. Default: `false`. |
| `smtpHost` | String | No | SMTP server hostname. Example: `smtp.gmail.com` |
| `smtpPort` | Integer | No | SMTP port. Use `587` for TLS or `465` for SSL. Default: `587`. |
| `smtpUser` | String | No | Your email address for SMTP authentication. |
| `smtpPass` | String | No | SMTP password or app-specific password (Gmail: generate at myaccount.google.com/apppasswords). |
| `recipientEmail` | String | No | Email address to send the availability summary to. |

---

#### Output example

```json
{
  "eventUrl": "https://www.etix.com/ticket/p/42269098/aew-presents-collision-philadelphia-2300-arena",
  "eventId": "42269098",
  "section": "FC LFT CTR",
  "row": "A",
  "seatLabel": "A101",
  "seatId": "7821345",
  "status": "Available",
  "scrapedAt": "2025-06-01T14:32:00.000Z"
}
````

***

#### Pricing

This Actor is **free to use** — you only pay for Apify platform compute time and proxy usage.

A typical run scraping 1 event (a few hundred available seats) costs approximately **$0.03–$0.08** in Apify platform credits.

New Apify accounts receive **$5 in free credits** — enough for dozens of scrape runs.

***

#### Technical notes

- **No account needed:** This Actor does not require an Etix login or cookies to operate
- **AWS WAF bypass:** Etix.com uses AWS WAF CAPTCHA. A [Capsolver](https://capsolver.com) API key (`capsolverApiKey` input) is required to run on Apify cloud — the Actor calls Capsolver's `AwsWafTaskProxyless` to solve the CAPTCHA automatically
- **Residential proxies:** Apify residential proxies are strongly recommended and set as default — datacenter IPs may trigger additional bot checks
- **Seat statuses:** Only seats with status `Available` are included in the output. Seats in someone's cart (`Temporary`) and sold seats (`Sold`) are excluded
- **Data freshness:** All data is scraped live on each run — there is no caching
- **Invalid URLs:** If a URL does not match the Etix event URL format (`/ticket/p/{eventId}/`), it will be skipped with an error log
- **Large events:** For events with 5,000+ seats, increase Actor memory to 1–2 GB for reliable performance

***

#### Support

Have questions or found a bug? Reach out:

- **Email:** ScrapySpider@protonmail.com
- **Website:** [ScrapySpider.com](https://ScrapySpider.com)
- **Apify:** Open a support issue on this Actor page
- **Response time:** Within 24–48 hours on weekdays

# Actor input Schema

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

One or more Etix.com event page URLs to scrape. Example: https://www.etix.com/ticket/p/12345678/event-name-venue

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

Proxy settings for the scraper. Defaults to Apify automatic proxy. Recommended to leave as default for best success rates.

## `capsolverApiKey` (type: `string`):

API key from capsolver.com to solve AWS WAF CAPTCHA challenges on Etix.com. Required to run on Apify cloud. Get one at https://capsolver.com

## `maxRetries` (type: `integer`):

Maximum number of retry attempts per event URL if a request fails. Increase for unreliable connections.

## `emailEnabled` (type: `boolean`):

Set to true to send an email summary of available seats after the run completes.

## `smtpHost` (type: `string`):

SMTP server hostname. Required if email notifications are enabled. Example: smtp.gmail.com

## `smtpPort` (type: `integer`):

SMTP server port. Common values: 587 (TLS) or 465 (SSL).

## `smtpUser` (type: `string`):

Your email address used for SMTP authentication.

## `smtpPass` (type: `string`):

Your SMTP password or app-specific password (for Gmail, generate at myaccount.google.com/apppasswords).

## `recipientEmail` (type: `string`):

Email address to send the availability summary to.

## Actor input object example

```json
{
  "eventUrls": [
    "https://www.etix.com/ticket/p/42269098/aew-presents-collision-philadelphia-2300-arena"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 3,
  "emailEnabled": false,
  "smtpPort": 587
}
```

# 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 = {
    "eventUrls": [
        "https://www.etix.com/ticket/p/42269098/aew-presents-collision-philadelphia-2300-arena"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/etix-ticket-availability-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 = {
    "eventUrls": ["https://www.etix.com/ticket/p/42269098/aew-presents-collision-philadelphia-2300-arena"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/etix-ticket-availability-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 '{
  "eventUrls": [
    "https://www.etix.com/ticket/p/42269098/aew-presents-collision-philadelphia-2300-arena"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapyspider/etix-ticket-availability-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etix.com Ticket Availability Scraper",
        "description": "Scrapes available seats from Etix.com event pages using the platform's internal seating chart API. Enter one or more event URLs and get all available seats with section, row, and seat label. Requires a Capsolver API key for AWS WAF bypass.",
        "version": "0.1",
        "x-build-id": "WburIBKplbbtgyiU5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~etix-ticket-availability-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-etix-ticket-availability-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapyspider~etix-ticket-availability-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-etix-ticket-availability-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapyspider~etix-ticket-availability-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-etix-ticket-availability-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "eventUrls"
                ],
                "properties": {
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "One or more Etix.com event page URLs to scrape. Example: https://www.etix.com/ticket/p/12345678/event-name-venue",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Defaults to Apify automatic proxy. Recommended to leave as default for best success rates."
                    },
                    "capsolverApiKey": {
                        "title": "Capsolver API Key",
                        "type": "string",
                        "description": "API key from capsolver.com to solve AWS WAF CAPTCHA challenges on Etix.com. Required to run on Apify cloud. Get one at https://capsolver.com"
                    },
                    "maxRetries": {
                        "title": "Max Retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of retry attempts per event URL if a request fails. Increase for unreliable connections.",
                        "default": 3
                    },
                    "emailEnabled": {
                        "title": "Enable Email Notification",
                        "type": "boolean",
                        "description": "Set to true to send an email summary of available seats after the run completes.",
                        "default": false
                    },
                    "smtpHost": {
                        "title": "SMTP Host",
                        "type": "string",
                        "description": "SMTP server hostname. Required if email notifications are enabled. Example: smtp.gmail.com"
                    },
                    "smtpPort": {
                        "title": "SMTP Port",
                        "minimum": 1,
                        "maximum": 65535,
                        "type": "integer",
                        "description": "SMTP server port. Common values: 587 (TLS) or 465 (SSL).",
                        "default": 587
                    },
                    "smtpUser": {
                        "title": "SMTP Username",
                        "type": "string",
                        "description": "Your email address used for SMTP authentication."
                    },
                    "smtpPass": {
                        "title": "SMTP Password",
                        "type": "string",
                        "description": "Your SMTP password or app-specific password (for Gmail, generate at myaccount.google.com/apppasswords)."
                    },
                    "recipientEmail": {
                        "title": "Recipient Email",
                        "type": "string",
                        "description": "Email address to send the availability summary to."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
