# SeatGeek Price Drop Monitor (`delta_tools/seatgeek-price-drop-monitor`) Actor

Track SeatGeek ticket prices across runs and get only price drops and new lows for the events you watch. Uses the official SeatGeek API with your free client ID. Baselines and unchanged prices are never charged.

- **URL**: https://apify.com/delta_tools/seatgeek-price-drop-monitor.md
- **Developed by:** [Delta Tools](https://apify.com/delta_tools) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 price changes

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

## SeatGeek Price Drop Monitor

**Stop rechecking ticket prices by hand. Get told when the price actually drops.**

This monitor watches SeatGeek events through the official SeatGeek API and reports only price drops and new lows. Run it on a schedule. When a price stays the same or goes up, you get no price change record and no price change charge. Your first run sets the baseline silently.

### Why it is different

- **Cross run price state built in.** Other SeatGeek Actors return a full snapshot every run and bill per row. This one remembers the lowest price it saw for each event and surfaces only what changed.
- **Official API only.** It uses the official SeatGeek API with your free client ID. It never scrapes the SeatGeek website.
- **Pay per price change, not per row.** You are billed per genuine drop or new low delivered. A scheduled run that finds no drop costs only the $0.001 start.
- **Useful context on every drop.** Each record carries the previous and current lowest price, the drop amount and percent, average and median price context, deal score, venue, date, and the all time low this watch has tracked.
- **Separate memories.** Give each scheduled monitor its own watch name in `stateKey` and their baselines never mix.
- **Auditable runs.** Every run writes a machine readable receipt in the state store with per watch fetch counts, change counts, and any errors.

### Setup

1. Register for a free SeatGeek developer account at seatgeek.com/account/develop and copy your client ID.
2. Paste it in `seatgeekClientId`.
3. Add one or more watches and run. Then put the same input on a schedule with a fixed `stateKey` so price memory carries across runs.

### Inputs

| Field | What it does |
|---|---|
| `watches` | Your watches. Each watch is an event watch with an `eventId`, a search watch with a `query` such as a team or artist name, or a performer watch with a `performerSlug`. |
| `seatgeekClientId` | **Free** client ID from seatgeek.com/account/develop. Required for price tracking. Without it, the run reports clearly in the dataset that SeatGeek was skipped, and charges no price change events. |
| `stateKey` | Namespace for this monitor memory. Use a different name per schedule. The prefilled default rotates daily so the free trial always starts fresh. |
| `resultsPerWatch` | Maximum events checked per watch in one run, from 1 to 50. |

Example input:

```json
{
  "watches": [
    {"type": "search", "query": "New York Yankees"},
    {"type": "event", "eventId": 1234567}
  ],
  "seatgeekClientId": "YOUR_FREE_CLIENT_ID",
  "stateKey": "yankees-watch"
}
```

### Output

One dataset row per price drop or new low:

| Field | Example |
|---|---|
| `changeType` | `price-drop` or `new-low` |
| `title` | event title on SeatGeek |
| `venue` | `Arena, New York, NY` |
| `eventDate` | event date and time |
| `previousLowestPrice` | `130` |
| `currentLowestPrice` | `110` |
| `dropAmount` | `20` |
| `dropPercent` | `15.38` |
| `url` | direct link to the event |

Every run also writes a run summary record. A run with no client ID writes a source status record that says SeatGeek was skipped and why, so a skipped run is never silent.

### Pricing

Pay per event:

- **Actor start:** $0.001
- **Price drop or new low delivered:** $0.003

A scheduled run that finds no drop costs only the $0.001 start. Compare: per row Actors bill you for every event they return again, every run.

### Notes and limits

- SeatGeek price tracking needs your free client ID. No key exists on our account, so the keyed route could not be tested end to end before launch. The no key path is tested live: it skips gracefully with a clear status record. The parser and the drop logic are unit tested and fixture tested.
- Version 1 tracks lowest price only. It does not return seat level listings.
- Prices come from SeatGeek at the moment of the run. A drop that appears and disappears between scheduled runs cannot be reported.

# Actor input Schema

## `resultsPerWatch` (type: `integer`):

Maximum SeatGeek events checked for each watch in one run.

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

Your free SeatGeek client ID. Register at seatgeek.com/account/develop and paste the client ID here. Required for price tracking. Without it the run reports clearly that SeatGeek was skipped and charges no price change events.

## `stateKey` (type: `string`):

Name your watch to give it its own memory. Runs that share a watch name share price state, so a scheduled watch only reports genuine drops. Leave empty for a fresh snapshot that resets daily, which suits one off trials.

## `watches` (type: `array`):

One watch per event, search, or performer. Use an event watch with an eventId from SeatGeek, a search watch with a query such as a team or artist name, or a performer watch with a performerSlug. Example: \[{"type": "search", "query": "New York Yankees"}, {"type": "event", "eventId": 1234567}]

## Actor input object example

```json
{
  "resultsPerWatch": 25,
  "watches": [
    {
      "query": "concert",
      "type": "search"
    }
  ]
}
```

# Actor output Schema

## `allTimeLow` (type: `string`):

Lowest price this watch has ever tracked for the event (as text).

## `averagePrice` (type: `string`):

Average ticket price context from SeatGeek (as text).

## `changeType` (type: `string`):

price-drop, new-low, or source-status.

## `currentLowestPrice` (type: `string`):

Lowest price on this run, in US dollars (as text).

## `dealScore` (type: `string`):

SeatGeek deal score for the event (as text).

## `detectedAt` (type: `string`):

UTC timestamp of the run that reported the change.

## `dropAmount` (type: `string`):

Drop in US dollars (as text).

## `dropPercent` (type: `string`):

Drop as a percent of the previous lowest price (as text).

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

Event date and time as SeatGeek reports it.

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

SeatGeek event identifier.

## `medianPrice` (type: `string`):

Median ticket price context from SeatGeek (as text).

## `performers` (type: `string`):

Performer names for the event.

## `previousLowestPrice` (type: `string`):

Lowest price on the previous run, in US dollars (as text).

## `priceChanges` (type: `string`):

Price changes reported, on the summary record (as text).

## `recordType` (type: `string`):

Record kind: price-change, source-status, or run-summary.

## `runAt` (type: `string`):

UTC timestamp of the run, on the summary record.

## `status` (type: `string`):

Present on source status records: skipped, results, no-results, or error.

## `summary` (type: `string`):

Plain language summary on status and summary records.

## `title` (type: `string`):

Event title on SeatGeek.

## `url` (type: `string`):

Link to the SeatGeek event page.

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

Venue name, city and state.

## `watch` (type: `string`):

The watch that found this change.

## `watchesChecked` (type: `string`):

Watches checked, on the summary record (as text).

# 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 = {
    "resultsPerWatch": 25,
    "watches": [
        {
            "query": "concert",
            "type": "search"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("delta_tools/seatgeek-price-drop-monitor").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 = {
    "resultsPerWatch": 25,
    "watches": [{
            "query": "concert",
            "type": "search",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("delta_tools/seatgeek-price-drop-monitor").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 '{
  "resultsPerWatch": 25,
  "watches": [
    {
      "query": "concert",
      "type": "search"
    }
  ]
}' |
apify call delta_tools/seatgeek-price-drop-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delta_tools/seatgeek-price-drop-monitor"
        }
    }
}
```

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/wKwbYi0kQHEGQx55B/builds/nsP1PKxTpfIf9Zzt6/openapi.json