# Ticket Price Drop & Availability Monitor (`dataforge_labs/event-ticket-price-availability-monitor`) Actor

Monitor Ticketmaster and StubHub events for price drops, new listings, sold-out inventory, back-in-stock tickets, and section-level availability changes.

- **URL**: https://apify.com/dataforge\_labs/event-ticket-price-availability-monitor.md
- **Developed by:** [Ula Ula](https://apify.com/dataforge_labs) (community)
- **Categories:** Sports, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Ticket Price Drop & Availability Monitor

Stop refreshing ticket pages. Get structured price-drop, availability, and
inventory-change events on a schedule.

This Apify Actor turns public Ticketmaster and StubHub event pages into a
persistent ticket-intelligence feed. It remembers the last complete
observation, compares each new run with that baseline, and emits auditable
change records for automation, alerts, dashboards, and market research.

It is a monitor, not another one-off ticket scraper.

### What it detects

- `NEW_LISTING` — a section or resale listing appears
- `PRICE_DROP` — price decreases by your configured threshold
- `PRICE_INCREASE` — price increases by your configured threshold
- `INVENTORY_CHANGED` — listing quantity or section inventory changes
- `SOLD_OUT` — an offer is absent for the configured number of complete runs
- `BACK_IN_STOCK` — a previously sold-out offer returns
- `EVENT_STATUS_CHANGED` — event status changes, for example to canceled

Every change contains stable target and offer IDs, the previous value, the
current value, detection time, platform, and source URL.

### Common use cases

- Alert fans when tickets get cheaper or return to inventory
- Track resale inventory for sports, concerts, theater, and festivals
- Monitor selected sections instead of an entire venue
- Build Telegram, Slack, email, or webhook notifications
- Collect ticket market history in a Dataset or external database
- Compare primary Ticketmaster supply with StubHub resale listings
- Feed structured ticket changes into Make, Zapier, n8n, or custom code

### Quick start

1. Add one or more public Ticketmaster or StubHub event URLs.
2. Set a stable `monitorId`.
3. Run once in `changes` mode to create the baseline.
4. Create an Apify Schedule, usually every 15–60 minutes.
5. Attach a webhook to receive change records after each run.

Example input:

```json
{
  "monitorId": "summer-concerts",
  "targets": [
    {
      "id": "ariana-chicago",
      "name": "Ariana Grande — Chicago",
      "url": "https://www.ticketmaster.com/ariana-grande-the-eternal-sunshine-tour-chicago-illinois-08-03-2026/event/04006319DDEA2CD5"
    },
    {
      "id": "celine-paris",
      "name": "Celine Dion — Paris",
      "url": "https://www.stubhub.com/celine-dion-nanterre-tickets-9-19-2026/event/160790802/?quantity=2",
      "minQuantity": 2,
      "sections": ["Floor", "101"]
    }
  ],
  "priceDropThresholdPercent": 5,
  "soldOutAfterMissingRuns": 2,
  "outputMode": "changes",
  "maxOffersPerTarget": 100,
  "maxUpstreamChargeUsd": 5
}
````

Keep the same `monitorId`, target IDs, filters, and offer limit across
scheduled runs. Changing the monitoring scope can legitimately create new or
missing-offer events.

### Output example

```json
{
  "record_type": "change",
  "event_type": "PRICE_DROP",
  "monitor_id": "summer-concerts",
  "target_id": "celine-paris",
  "platform": "stubhub",
  "ticket_event_id": "160790802",
  "offer_id": "sh:160790802:listing:12316339801",
  "changed_fields": ["price"],
  "before": {
    "section": "411",
    "row": "54",
    "price": 214.76,
    "currency": "USD",
    "quantity": 2
  },
  "after": {
    "section": "411",
    "row": "54",
    "price": 189.5,
    "currency": "USD",
    "quantity": 2
  },
  "detected_at": "2026-07-14T12:00:00Z",
  "source_url": "https://www.stubhub.com/.../event/160790802/"
}
```

The `OUTPUT` Key-Value Store record contains a run summary with:

- succeeded and failed targets
- offers observed
- changes by type
- child Actor run IDs
- actual upstream cost when available
- per-target completeness warnings

### Output modes

#### `changes`

Recommended for scheduled monitoring. The first successful run creates a
baseline and hides initial `NEW_LISTING` records. Later runs emit changes only.

#### `all`

Includes `NEW_LISTING` records from the initial baseline. Use it when the
initial inventory is part of your workflow.

#### `all_current`

Returns one current snapshot/status record per target and never updates the
persistent baseline. This is useful for previews, one-off checks, debugging,
and Apify Store health checks. Failed or ambiguous empty observations are
reported as `unknown`, not as sold out.

### Filters

- `sections` matches case-insensitive section-name fragments.
- `quantity` sets a global minimum adjacent ticket quantity.
- `minQuantity` overrides quantity for one target.
- `priceDropThresholdPercent` ignores smaller price movements.
- `maxOffersPerTarget` bounds runtime and upstream spend.

Ticketmaster currently provides section-level minimum prices and inventory
counts. StubHub provides listing-level prices, rows, and quantities when the
selected upstream exposes them.

### Safe stateful monitoring

Ticket pages and upstream scrapers can fail, get blocked, or return a truncated
result. Treating every empty response as sold out would create bad alerts.

This Actor therefore:

- isolates state by a hash of `monitorId`
- versions the stored state schema
- saves after each successful target
- does not mutate state after failed or capped child runs
- rejects suspicious inventory collapses
- requires consecutive complete absences before `SOLD_OUT`
- never compares prices in different currencies
- preserves `before` and `after` evidence

An empty upstream Dataset with no explicit event status is ambiguous. It is
reported as incomplete and does not erase a healthy baseline.

### Schedules and webhooks

For most events:

- every 60 minutes for long-range tracking
- every 15–30 minutes during the final week
- every 5–15 minutes only when freshness justifies the extra upstream cost

Configure a webhook for `ACTOR.RUN.SUCCEEDED` and fetch Dataset items from the
run. A successful run may correctly contain zero change records in `changes`
mode; use the `OUTPUT` record to distinguish “no changes” from target failures.

### API

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor(
    "dataforge_labs/event-ticket-price-availability-monitor"
).call(run_input={
    "monitorId": "my-monitor",
    "targets": [{
        "id": "event-1",
        "url": "https://www.ticketmaster.com/.../event/04006319DDEA2CD5"
    }],
    "outputMode": "changes"
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
```

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client
  .actor('dataforge_labs/event-ticket-price-availability-monitor')
  .call({
    monitorId: 'my-monitor',
    targets: [{
      id: 'event-1',
      url: 'https://www.stubhub.com/.../event/160790802/'
    }],
    outputMode: 'changes',
  });

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

REST:

```text
POST https://api.apify.com/v2/acts/dataforge_labs~event-ticket-price-availability-monitor/runs?token=YOUR_APIFY_TOKEN
```

### Pricing and spend controls

The Actor uses replaceable Apify Store Actors to retrieve ticket data, so users
do not need Ticketmaster or StubHub API keys. Your run can include:

1. this Actor's pay-per-event charges, and
2. the selected child Actor's usage or pay-per-result charges.

`maxUpstreamChargeUsd` is a hard child-Actor spend ceiling divided equally
across targets. `maxOffersPerTarget` and schedule frequency are the main cost
controls. The run summary reports child run IDs and available cost data.

Default upstreams are selected from paid repeat benchmarks and can be replaced
with `ticketmasterActorId`, `stubhubActorId`, and the corresponding input
override objects.

### Limitations

- Public page structure, bot protection, regional availability, and upstream
  Actor behavior can change.
- Ticketmaster section pricing is not seat-level inventory.
- StubHub listing IDs and availability depend on what the upstream returns.
- Fees and taxes may not be included in every displayed price.
- Currency conversion is not performed.
- A capped result is intentionally not accepted as a new baseline.
- This Actor does not reserve or buy tickets.
- CAPTCHA, login, checkout, queue bypass, and auto-purchase are not supported.

### Responsible use

Monitor public event pages at a reasonable frequency. Follow applicable terms,
laws, and platform policies. Do not use this Actor to evade access controls,
interfere with ticket queues, automate checkout, or facilitate abusive resale.

### FAQ

#### Why was my first `changes` Dataset empty?

The first successful run establishes the baseline. Use `all` to include initial
listings or `all_current` for a non-mutating snapshot.

#### Why does a run say `unknown` instead of `sold_out`?

The child Actor returned no trustworthy rows and no explicit sold-out status.
The monitor protects your baseline instead of creating a false alert.

#### Can I monitor only two adjacent tickets?

Yes. Set `quantity: 2` globally or `minQuantity: 2` on one StubHub target.

#### Can I monitor a specific section?

Yes. Add case-insensitive fragments such as `["Floor", "101"]`.

#### Can I use another scraper?

Yes. Override the platform Actor ID and vendor input. The output must still
match one of the supported adapter shapes; test it in `all_current` first.

#### Does it auto-buy tickets?

No. The product provides ticket intelligence and change events only.

# Actor input Schema

## `monitorId` (type: `string`):

Reuse this ID on every scheduled run to preserve the baseline.

## `targets` (type: `array`):

One to 100 public event URLs. Give each event a stable unique ID.

## `priceDropThresholdPercent` (type: `number`):

Ignore smaller price increases and drops.

## `quantity` (type: `integer`):

Optional default applied when a target has no minQuantity.

## `sections` (type: `array`):

Case-insensitive section-name fragments.

## `outputMode` (type: `string`):

Emit changes, include initial listings, or return current snapshots without changing the baseline.

## `soldOutAfterMissingRuns` (type: `integer`):

Consecutive complete observations required before a listing is marked sold out.

## `maxOffersPerTarget` (type: `integer`):

Higher limits improve completeness but cost more and run longer.

## `maxParallelTargets` (type: `integer`):

Maximum number of child Actor calls running concurrently.

## `maxUpstreamChargeUsd` (type: `number`):

Hard PPE ceiling split equally across child Actor calls.

## `ticketmasterActorId` (type: `string`):

Advanced: replace the selected Ticketmaster adapter.

## `stubhubActorId` (type: `string`):

Advanced: replace the selected StubHub adapter.

## `ticketmasterInputOverrides` (type: `object`):

Advanced vendor-specific values merged into generated Ticketmaster input.

## `stubhubInputOverrides` (type: `object`):

Advanced vendor-specific values merged into generated StubHub input.

## Actor input object example

```json
{
  "monitorId": "apify-store-healthcheck",
  "targets": [
    {
      "id": "lindsey-charlotte-2026",
      "name": "Lindsey Stirling — Charlotte",
      "platform": "ticketmaster",
      "url": "https://www.ticketmaster.com/lindsey-stirling-duality-untamed-tour-charlotte-north-carolina-07-18-2026/event/2D0064359C6EB515"
    }
  ],
  "priceDropThresholdPercent": 5,
  "sections": [],
  "outputMode": "all_current",
  "soldOutAfterMissingRuns": 2,
  "maxOffersPerTarget": 100,
  "maxParallelTargets": 4,
  "maxUpstreamChargeUsd": 1,
  "ticketmasterActorId": "unfenced-group/ticketmaster-price-monitor",
  "stubhubActorId": "stealth_mode/stubhub-tickets-listings-scraper",
  "ticketmasterInputOverrides": {},
  "stubhubInputOverrides": {}
}
```

# Actor output Schema

## `records` (type: `string`):

No description

## `summary` (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 = {
    "monitorId": "apify-store-healthcheck",
    "targets": [
        {
            "id": "lindsey-charlotte-2026",
            "name": "Lindsey Stirling — Charlotte",
            "platform": "ticketmaster",
            "url": "https://www.ticketmaster.com/lindsey-stirling-duality-untamed-tour-charlotte-north-carolina-07-18-2026/event/2D0064359C6EB515"
        }
    ],
    "outputMode": "all_current",
    "maxOffersPerTarget": 100,
    "maxUpstreamChargeUsd": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataforge_labs/event-ticket-price-availability-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 = {
    "monitorId": "apify-store-healthcheck",
    "targets": [{
            "id": "lindsey-charlotte-2026",
            "name": "Lindsey Stirling — Charlotte",
            "platform": "ticketmaster",
            "url": "https://www.ticketmaster.com/lindsey-stirling-duality-untamed-tour-charlotte-north-carolina-07-18-2026/event/2D0064359C6EB515",
        }],
    "outputMode": "all_current",
    "maxOffersPerTarget": 100,
    "maxUpstreamChargeUsd": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("dataforge_labs/event-ticket-price-availability-monitor").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 '{
  "monitorId": "apify-store-healthcheck",
  "targets": [
    {
      "id": "lindsey-charlotte-2026",
      "name": "Lindsey Stirling — Charlotte",
      "platform": "ticketmaster",
      "url": "https://www.ticketmaster.com/lindsey-stirling-duality-untamed-tour-charlotte-north-carolina-07-18-2026/event/2D0064359C6EB515"
    }
  ],
  "outputMode": "all_current",
  "maxOffersPerTarget": 100,
  "maxUpstreamChargeUsd": 1
}' |
apify call dataforge_labs/event-ticket-price-availability-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ticket Price Drop & Availability Monitor",
        "description": "Monitor Ticketmaster and StubHub events for price drops, new listings, sold-out inventory, back-in-stock tickets, and section-level availability changes.",
        "version": "0.1",
        "x-build-id": "76npRCY6LXHWeGmYr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dataforge_labs~event-ticket-price-availability-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dataforge_labs-event-ticket-price-availability-monitor",
                "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/dataforge_labs~event-ticket-price-availability-monitor/runs": {
            "post": {
                "operationId": "runs-sync-dataforge_labs-event-ticket-price-availability-monitor",
                "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/dataforge_labs~event-ticket-price-availability-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-dataforge_labs-event-ticket-price-availability-monitor",
                "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": [
                    "monitorId",
                    "targets"
                ],
                "properties": {
                    "monitorId": {
                        "title": "Stable monitor ID",
                        "pattern": "^[A-Za-z0-9_-]{1,100}$",
                        "type": "string",
                        "description": "Reuse this ID on every scheduled run to preserve the baseline."
                    },
                    "targets": {
                        "title": "Ticketmaster or StubHub events",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "One to 100 public event URLs. Give each event a stable unique ID.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": {
                                    "title": "Target ID",
                                    "type": "string",
                                    "description": "Stable key used in state and change events."
                                },
                                "name": {
                                    "title": "Display name",
                                    "type": "string",
                                    "description": "Optional human-readable label for output and alerts."
                                },
                                "platform": {
                                    "title": "Platform",
                                    "type": "string",
                                    "description": "Detected from the URL when omitted.",
                                    "enum": [
                                        "ticketmaster",
                                        "stubhub"
                                    ]
                                },
                                "url": {
                                    "title": "Public event URL",
                                    "type": "string",
                                    "description": "Full public Ticketmaster or StubHub event page URL."
                                },
                                "eventId": {
                                    "title": "Platform event ID",
                                    "type": "string",
                                    "description": "Ticketmaster can be checked by ID without a URL."
                                },
                                "sections": {
                                    "title": "Section name filters",
                                    "type": "array",
                                    "description": "Optional case-insensitive section-name fragments.",
                                    "items": {
                                        "type": "string"
                                    }
                                },
                                "minQuantity": {
                                    "title": "Minimum adjacent quantity",
                                    "type": "integer",
                                    "description": "Ignore StubHub listings with fewer available tickets.",
                                    "minimum": 1,
                                    "maximum": 20
                                }
                            }
                        }
                    },
                    "priceDropThresholdPercent": {
                        "title": "Minimum price change (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Ignore smaller price increases and drops.",
                        "default": 5
                    },
                    "quantity": {
                        "title": "Global minimum adjacent quantity",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Optional default applied when a target has no minQuantity."
                    },
                    "sections": {
                        "title": "Global section filters",
                        "type": "array",
                        "description": "Case-insensitive section-name fragments.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "changes",
                            "all",
                            "all_current"
                        ],
                        "type": "string",
                        "description": "Emit changes, include initial listings, or return current snapshots without changing the baseline.",
                        "default": "changes"
                    },
                    "soldOutAfterMissingRuns": {
                        "title": "Missing runs before SOLD_OUT",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Consecutive complete observations required before a listing is marked sold out.",
                        "default": 2
                    },
                    "maxOffersPerTarget": {
                        "title": "Maximum offers per event",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Higher limits improve completeness but cost more and run longer.",
                        "default": 100
                    },
                    "maxParallelTargets": {
                        "title": "Parallel event checks",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of child Actor calls running concurrently.",
                        "default": 4
                    },
                    "maxUpstreamChargeUsd": {
                        "title": "Total upstream spend limit (USD)",
                        "minimum": 0.01,
                        "maximum": 100,
                        "type": "number",
                        "description": "Hard PPE ceiling split equally across child Actor calls.",
                        "default": 5
                    },
                    "ticketmasterActorId": {
                        "title": "Ticketmaster upstream Actor",
                        "type": "string",
                        "description": "Advanced: replace the selected Ticketmaster adapter.",
                        "default": "unfenced-group/ticketmaster-price-monitor"
                    },
                    "stubhubActorId": {
                        "title": "StubHub upstream Actor",
                        "type": "string",
                        "description": "Advanced: replace the selected StubHub adapter.",
                        "default": "stealth_mode/stubhub-tickets-listings-scraper"
                    },
                    "ticketmasterInputOverrides": {
                        "title": "Ticketmaster input overrides",
                        "type": "object",
                        "description": "Advanced vendor-specific values merged into generated Ticketmaster input.",
                        "default": {}
                    },
                    "stubhubInputOverrides": {
                        "title": "StubHub input overrides",
                        "type": "object",
                        "description": "Advanced vendor-specific values merged into generated StubHub input.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```