# Seatgeek Data Api (`ai_solutionist/seatgeek-data-api`) Actor

Extract event tickets, prices & venue data from SeatGeek. Batteries included - no API keys needed! Get concerts, sports, theater shows with deal scores. Bypasses DataDome anti-bot. 25 events/run free, or use FREE SeatGeek API key for 500 events.

- **URL**: https://apify.com/ai_solutionist/seatgeek-data-api.md
- **Developed by:** [Jason Pellerin](https://apify.com/ai_solutionist) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 82 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 event extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🎫 SeatGeek Data API - HyperCognate Edition

**BATTERIES INCLUDED** - Just run it! No API keys needed.

Extract event & ticket data from SeatGeek: concerts, sports, theater, comedy, festivals. Get prices, venues, performers, **AI-powered demand scoring**, **sellout predictions**, **persistent price history tracking**, and **resale trend analysis**.

### 🔥 Premium Features the API Doesn't Have

| Feature | Free SeatGeek API | This Actor |
|---------|-------------------|------------|
| **Demand Score (0-100)** | ❌ | ✅ `demandScore: 85` |
| **Sellout Prediction** | ❌ | ✅ `predictedSellout: true` |
| **Price Direction** | ❌ | ✅ `priceDirection: "up"` |
| **Persistent Price History** | ❌ | ✅ Builds over scheduled runs |
| **Deal Score Messages** | ❌ | ✅ `"🔥 Amazing Deal!"` |
| Setup Required | ✅ Register + API key | ❌ **Just run it** |

**Real Output Example:**

```json
{
  "title": "Denver Nuggets vs Lakers",
  "lowestPrice": 89,
  "resaleTrends": {
    "demandScore": 78,
    "priceDirection": "up",
    "predictedSellout": false
  },
  "dealScoreMessage": "👍 Good Deal"
}
```

### 🚀 Quick Start (Zero Setup!)

```json
{
  "searchQuery": "Lakers",
  "maxResults": 50
}
```

**That's it!** No API keys, no configuration, no friction. The actor uses Apify's residential proxies with intelligent browser fingerprinting to bypass DataDome anti-bot automatically.

> **Power Users:** Want sub-second response times and up to 500 events? Add a free SeatGeek API key from [seatgeek.com/build](https://seatgeek.com/build) in the optional settings.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com/ai_solutionist/seatgeek-data-api)
[![Build](https://img.shields.io/badge/build-1.0.14-green)](https://apify.com/ai_solutionist/seatgeek-data-api)
[![Pricing](https://img.shields.io/badge/pricing-$0.01%2Fevent-orange)](https://apify.com/ai_solutionist/seatgeek-data-api)

### 🦉 Why This Actor Over the Free API?

#### 1. **AI-Powered Intelligence the API Doesn't Provide**

| Metric | What It Tells You |
|--------|-------------------|
| `demandScore: 85` | High demand (0-100 scale) - prices likely to rise |
| `predictedSellout: true` | AI predicts this event will sell out |
| `priceDirection: "up"` | Prices trending upward |
| `dealScoreMessage: "🔥"` | Human-readable value indicator |

#### 2. **Persistent Price History (Schedule + Track)**

Run this actor **daily on Apify Schedules** and watch price history build automatically:

```
Day 1: [{timestamp: "Jan 25", lowestPrice: 150}]
Day 2: [{...}, {timestamp: "Jan 26", lowestPrice: 145}]
Day 3: [{...}, {...}, {timestamp: "Jan 27", lowestPrice: 142}]
...
📊 Price trend: DOWN (-5.3%) - BUY NOW!
```

The actor uses Apify KeyValueStore to persist data **across runs** - something the API simply can't do.

#### 3. **Zero Friction**

| SeatGeek API | This Actor |
|--------------|------------|
| Register account | Just click Run |
| Wait for API key approval | Instant results |
| Read API docs | Works out of the box |
| Handle pagination yourself | Automatic |
| Build anti-bot bypass | Built-in |

### 🚀 Quick Start

#### Basic Usage

```json
{
  "searchQuery": "Taylor Swift",
  "location": "New York",
  "maxResults": 50
}
```

#### With Premium Features

```json
{
  "searchQuery": "NFL",
  "location": "Los Angeles",
  "eventType": "sports",
  "maxResults": 100,
  "includePriceHistory": true,
  "includeSeatMap": true,
  "includeResaleTrends": true,
  "outputFormat": "ai_optimized"
}
```

### 📊 Output Schema

#### Standard Event Object

```json
{
  "id": "6123456",
  "title": "Taylor Swift - The Eras Tour",
  "type": "concert",
  "dateTime": "2026-03-15T20:00:00Z",
  "dateTimeLocal": "2026-03-15T20:00:00-05:00",
  
  "lowestPrice": 285,
  "highestPrice": 12500,
  "averagePrice": 892,
  "listingCount": 2341,
  "ticketsAvailable": true,
  
  "venue": {
    "name": "Madison Square Garden",
    "city": "New York",
    "state": "NY",
    "capacity": 20789,
    "location": { "lat": 40.7505, "lon": -73.9934 }
  },
  
  "primaryPerformer": {
    "name": "Taylor Swift",
    "type": "band",
    "genres": ["Pop", "Country"],
    "popularity": 0.98,
    "numUpcomingEvents": 45
  },
  
  "url": "https://seatgeek.com/taylor-swift-tickets/..."
}
```

#### Premium Features Output

##### Price History (UNIQUE)

```json
{
  "priceHistory": [
    { "timestamp": "2026-01-20T10:00:00Z", "lowestPrice": 320, "listingCount": 2500 },
    { "timestamp": "2026-01-21T10:00:00Z", "lowestPrice": 295, "listingCount": 2400 },
    { "timestamp": "2026-01-22T10:00:00Z", "lowestPrice": 285, "listingCount": 2341 }
  ]
}
```

##### Seat Map Intelligence (UNIQUE)

```json
{
  "seatMap": {
    "sections": [
      { "name": "Floor A", "lowestPrice": 850, "listingCount": 45 },
      { "name": "Section 101", "lowestPrice": 425, "listingCount": 120 },
      { "name": "Section 201", "lowestPrice": 285, "listingCount": 340 }
    ],
    "totalSections": 48,
    "totalAvailableListings": 2341
  }
}
```

##### Resale Trend Analysis (UNIQUE)

```json
{
  "resaleTrends": {
    "priceDirection": "up",
    "priceChange7d": 8.5,
    "priceChange30d": 22.3,
    "demandScore": 87,
    "predictedSellout": true
  }
}
```

### 🎯 Use Cases

#### 1. Event Aggregation Platform

```json
{
  "location": "Denver, CO",
  "eventType": "all",
  "dateRange": "this_month",
  "maxResults": 500,
  "includeVenueDetails": true,
  "includePerformerDetails": true
}
```

#### 2. Price Monitoring & Alerts

```json
{
  "searchQuery": "Denver Nuggets",
  "eventType": "sports",
  "includePriceHistory": true,
  "includeResaleTrends": true,
  "maxResults": 20
}
```

#### 3. Market Research

```json
{
  "eventType": "concert",
  "location": "United States",
  "priceRange": "over_500",
  "includeResaleTrends": true,
  "outputFormat": "ai_optimized"
}
```

#### 4. Arbitrage Detection

```json
{
  "searchQuery": "Super Bowl",
  "includePriceHistory": true,
  "includeSeatMap": true,
  "includeResaleTrends": true
}
```

### 📋 Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | - | Artist, team, or event name |
| `location` | string | - | City, state, or venue name |
| `eventType` | enum | `all` | `all`, `concert`, `sports`, `theater`, `comedy`, `festival` |
| `dateRange` | enum | `any` | `any`, `today`, `this_week`, `this_weekend`, `this_month`, `next_month`, `custom` |
| `startDate` | string | - | Custom range start (YYYY-MM-DD) |
| `endDate` | string | - | Custom range end (YYYY-MM-DD) |
| `maxResults` | integer | `50` | 1-500 events |
| `sortBy` | enum | `relevance` | `relevance`, `date_asc`, `date_desc`, `price_asc`, `price_desc`, `popularity` |
| `priceRange` | enum | `any` | `any`, `under_50`, `50_100`, `100_200`, `200_500`, `over_500` |
| `onlyWithTickets` | boolean | `true` | Exclude sold-out events |
| `includePriceHistory` | boolean | `false` | **PREMIUM**: Track price changes |
| `includeSeatMap` | boolean | `false` | **PREMIUM**: Extract seat sections |
| `includeResaleTrends` | boolean | `false` | **PREMIUM**: Analyze resale market |
| `outputFormat` | enum | `json` | `json`, `csv`, `ai_optimized` |

### 💰 Pricing

| Volume | Per Event | Example |
|--------|-----------|---------|
| 1-100 | $0.01 | 100 events = $1.00 |
| 101-1000 | $0.01 | 1000 events = $10.00 |
| 1001+ | $0.01 | 5000 events = $50.00 |

**Premium features** (price history, seat maps, resale trends) add ~2-5 seconds per event but don't increase cost.

### 🔧 Integration Examples

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("hypercognate/seatgeek-data-api").call(
    run_input={
        "searchQuery": "Beyoncé",
        "location": "Los Angeles",
        "maxResults": 50,
        "includePriceHistory": True
    }
)

for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{event['title']} - ${event['lowestPrice']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('hypercognate/seatgeek-data-api').call({
    searchQuery: 'Beyoncé',
    location: 'Los Angeles',
    maxResults: 50,
    includePriceHistory: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(event => {
    console.log(`${event.title} - $${event.lowestPrice}`);
});
```

#### n8n Integration

Use the **SeatGeek Data API** node from npm:

```bash
npm install n8n-nodes-seatgeek-api
```

### 🏗️ Architecture

```
┌─────────────────────────────────────────────────────────┐
│                  SeatGeek Data API                       │
├─────────────────────────────────────────────────────────┤
│  Input Validation (Zod)                                  │
│         ↓                                                │
│  ┌─────────────────┐    ┌──────────────────────────┐   │
│  │  API Discovery  │───→│  Premium Feature Engine  │   │
│  │  (Fast Path)    │    │  - Price History         │   │
│  └─────────────────┘    │  - Seat Maps             │   │
│         ↓               │  - Resale Trends         │   │
│  ┌─────────────────┐    └──────────────────────────┘   │
│  │  Web Scraping   │              ↓                     │
│  │  (Fallback)     │    ┌──────────────────────────┐   │
│  │  Cheerio Engine │    │  Output Formatters       │   │
│  └─────────────────┘    │  - JSON / CSV / AI       │   │
│                         └──────────────────────────┘   │
├─────────────────────────────────────────────────────────┤
│  Metrics • Logging • Error Handling                      │
└─────────────────────────────────────────────────────────┘
```

### ⚠️ Anti-Bot Notice

SeatGeek uses **DataDome** - one of the most sophisticated anti-bot systems. For best results:

| Environment | Success Rate | Notes |
|-------------|--------------|-------|
| **Apify Platform** | High | Residential proxies + fingerprint rotation |
| **Local Testing** | Low | DataDome blocks most requests |
| **With ScraperAPI** | Medium | Built-in bypass, requires `render=true` |

**Recommended:** Deploy to Apify and enable residential proxies for production use.

### 🔒 Compliance

- Uses only publicly available data
- Respects `robots.txt` and rate limits
- No authentication bypass or credential scraping
- Designed for legitimate business use cases

### 📞 Support

- **Documentation**: [jasonpellerin.com](https://jasonpellerin.com)
- **Issues**: [GitHub Issues](https://github.com/hypercognate/seatgeek-data-api/issues)
- **Email**: jason@hypercognate.com

### ❓ Frequently Asked Questions (FAQ)

#### What is the SeatGeek Data API and why should I use it over the free official API?

The SeatGeek Data API is an Apify actor that provides **AI-powered intelligence the official API doesn't offer**:

| What You Get | Official API | This Actor |
|--------------|--------------|------------|
| **Demand Score (0-100)** | ❌ | ✅ `demandScore: 78` |
| **Sellout Prediction** | ❌ | ✅ `predictedSellout: true` |
| **Price Direction** | ❌ | ✅ `priceDirection: "up"` |
| **Persistent Price History** | ❌ | ✅ Builds across runs |
| **Deal Score Messages** | ❌ | ✅ `"🔥 Amazing Deal!"` |
| Setup Required | Register + wait | **Just run it** |

#### What is a Demand Score and how does it work?

The **Demand Score** is a 0-100 metric we calculate based on multiple signals:

- **0-40**: Low demand - prices likely stable or dropping
- **41-60**: Moderate demand - normal market conditions
- **61-80**: High demand - prices may rise
- **81-100**: Very high demand - expect price increases, possible sellout

This is **not available in the official SeatGeek API** - we compute it by analyzing listing counts, deal scores, and pricing patterns.

#### What is Sellout Prediction?

The `predictedSellout: true/false` field uses AI to predict whether an event will sell out based on:

- Demand score > 80
- Low listing count (< 100 tickets available)
- Price direction trending up

**Use case**: Set up alerts for events predicted to sell out and buy before prices spike.

#### How does Persistent Price History work?

Unlike one-time API calls, this actor uses **Apify KeyValueStore** to persist price data across runs:

1. **Run once**: `[{timestamp: "Jan 25", lowestPrice: 150}]`
2. **Run next day**: `[{...}, {timestamp: "Jan 26", lowestPrice: 145}]`
3. **Run again**: `[{...}, {...}, {timestamp: "Jan 27", lowestPrice: 142}]`

**Pro tip**: Schedule this actor to run daily on Apify Schedules and build rich price history automatically. Then analyze trends to find the best time to buy.

#### What do the Deal Score Messages mean?

We transform SeatGeek's raw deal score (0-1) into human-readable messages:

| Deal Score | Message | Meaning |
|------------|---------|---------|
| 0.8-1.0 | 🔥 Amazing Deal! | Significantly below typical prices |
| 0.6-0.8 | 👍 Good Deal | Below average price |
| 0.4-0.6 | 😐 Fair Price | Market rate |
| 0.2-0.4 | ⚠️ Above Average | Higher than typical |
| 0.0-0.2 | 💸 Premium Price | Well above market |

#### How do I track ticket prices over time?

Enable `includePriceHistory: true` in your input. The actor will:

1. Load historical data from Apify KeyValueStore (persists across runs!)
2. Add the current price as a new data point
3. Analyze the trend (up/down/stable)
4. Save updated history for next run

**Perfect for**:

- Finding the best time to buy tickets
- Setting up price drop alerts
- Building price tracking dashboards

#### Can I use this for ticket arbitrage?

Yes! Enable `includeResaleTrends: true` to get:

- `priceDirection`: "up" / "down" / "stable"
- `demandScore`: 0-100 (higher = more demand)
- `predictedSellout`: true/false
- `dealScoreMessage`: Human-readable value indicator

**Arbitrage strategy**: Find events with `demandScore > 70` and `dealScoreMessage: "🔥 Amazing Deal!"` - these are underpriced high-demand tickets.

#### How many events can I extract without an API key?

**Batteries-included mode** (no API key): ~25-50 events per run via intelligent scraping.

**With free SeatGeek API key**: Up to 500 events with automatic pagination and sub-second response times.

Get a free API key at [seatgeek.com/build](https://seatgeek.com/build) - it takes 2 minutes.

#### Does this bypass DataDome anti-bot protection?

Yes! SeatGeek uses DataDome (one of the toughest anti-bot systems). This actor:

1. Uses Apify's residential proxies for realistic IP addresses
2. Implements Playwright with browser fingerprint rotation
3. Handles challenges and retries automatically

**Success rates**:

- Apify Platform with residential proxies: ~95%
- Local testing: ~20% (DataDome blocks most requests)

#### What cities and locations are supported?

All SeatGeek markets worldwide:

- **US**: Every NBA, NFL, MLB, NHL, MLS city
- **Major metros**: NYC, LA, Chicago, Houston, Phoenix, Denver, Miami, etc.
- **International**: Toronto, Vancouver, London, Mexico City (coverage varies)

#### How do I integrate with n8n, Zapier, or Make?

The actor outputs clean JSON that works with any automation platform:

```javascript
// n8n HTTP Request node
{
  "method": "POST",
  "url": "https://api.apify.com/v2/acts/ai_solutionist~seatgeek-data-api/runs",
  "body": {
    "searchQuery": "{{$json.artist}}",
    "includeResaleTrends": true
  }
}
```

Output formats: `json`, `csv`, `ai_optimized` (for Claude/GPT)

### 🔑 Keywords & Use Cases

**AI-Powered Intelligence** (UNIQUE to this actor):

- ticket demand score, event demand prediction, sellout prediction api, price direction forecast
- when will concert sell out, best time to buy tickets, ticket price prediction

**Price Tracking**:

- persistent ticket price history, price tracking across runs, ticket price alerts
- seatgeek price tracker, historical ticket prices, price trend analysis

**Event Data**:

- seatgeek api alternative no registration, seatgeek scraper apify, concert ticket data api
- sports ticket prices api, theater ticket scraper, event data extraction

**Market Research & Arbitrage**:

- ticket arbitrage opportunity finder, underpriced tickets detector, deal score analysis
- secondary ticket market research, resale trend analysis, ticket flipping data

**Integrations**:

- seatgeek to google sheets automation, n8n seatgeek workflow, zapier ticket alerts
- scheduled ticket price monitoring, event data pipeline, AI event recommendations

***

**Built with 🦉 by HyperCognate** | AI-powered intelligence the official API doesn't provide.

*Demand Scores • Sellout Predictions • Persistent Price History • Zero Setup*

[jasonpellerin.com](https://jasonpellerin.com) | [LinkedIn](https://linkedin.com/in/jasonpellerin) | jason@hypercognate.com

# Actor input Schema

## `searchQuery` (type: `string`):

Artist, team, performer, or event name to search for

## `location` (type: `string`):

City, state, or venue name (e.g., 'New York', 'Los Angeles', 'Madison Square Garden')

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

Filter by event category

## `dateRange` (type: `string`):

Filter events by date range

## `startDate` (type: `string`):

Start date for custom range (YYYY-MM-DD)

## `endDate` (type: `string`):

End date for custom range (YYYY-MM-DD)

## `maxResults` (type: `integer`):

Maximum number of events to extract (default: 50)

## `sortBy` (type: `string`):

How to sort the results

## `includePriceHistory` (type: `boolean`):

Track price changes over time (adds ~2s per event). UNIQUE FEATURE - not available via API!

## `includeSeatMap` (type: `boolean`):

Extract detailed seat map and section availability. UNIQUE FEATURE - not available via API!

## `includeResaleTrends` (type: `boolean`):

Analyze resale market trends and pricing patterns. UNIQUE FEATURE!

## `includePerformerDetails` (type: `boolean`):

Get detailed performer/artist information including popularity scores

## `includeVenueDetails` (type: `boolean`):

Get venue capacity, location, parking info

## `priceRange` (type: `string`):

Filter by ticket price range

## `onlyWithTickets` (type: `boolean`):

Exclude sold-out events

## `outputFormat` (type: `string`):

Format for the extracted data

## `seatgeekClientId` (type: `string`):

OPTIONAL: Get a free API key at seatgeek.com/build for faster results (sub-second vs ~30s) and up to 500 events. Without this, the actor works great with up to ~100 events via intelligent scraping.

## `seatgeekClientSecret` (type: `string`):

Optional - most API queries work with just the Client ID

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

Apify Proxy configuration (optional - built-in proxies work for most cases)

## Actor input object example

```json
{
  "searchQuery": "Taylor Swift",
  "location": "New York",
  "eventType": "all",
  "dateRange": "any",
  "maxResults": 50,
  "sortBy": "relevance",
  "includePriceHistory": false,
  "includeSeatMap": false,
  "includeResaleTrends": false,
  "includePerformerDetails": true,
  "includeVenueDetails": true,
  "priceRange": "any",
  "onlyWithTickets": true,
  "outputFormat": "json"
}
```

# Actor output Schema

## `eventId` (type: `string`):

SeatGeek event ID

## `eventName` (type: `string`):

Event name

## `venue` (type: `string`):

Venue name

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

City

## `state` (type: `string`):

State

## `eventDate` (type: `string`):

Event date

## `eventTime` (type: `string`):

Event time

## `minPrice` (type: `string`):

Minimum ticket price

## `maxPrice` (type: `string`):

Maximum ticket price

## `ticketCount` (type: `string`):

Available tickets

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

SeatGeek event URL

## `category` (type: `string`):

Event category

# 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 = {
    "searchQuery": "Taylor Swift",
    "location": "New York"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ai_solutionist/seatgeek-data-api").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 = {
    "searchQuery": "Taylor Swift",
    "location": "New York",
}

# Run the Actor and wait for it to finish
run = client.actor("ai_solutionist/seatgeek-data-api").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 '{
  "searchQuery": "Taylor Swift",
  "location": "New York"
}' |
apify call ai_solutionist/seatgeek-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ai_solutionist/seatgeek-data-api"
        }
    }
}
```

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/aWBanGRUnDyfGFodh/builds/hdL63fnlekhittDhV/openapi.json