# Gametime Event Tickets Scraper (`automation-lab/gametime-event-tickets-prices`) Actor

Export Gametime event ticket offers with section, row, per-ticket prices including fees, selected quantity, venue and observation time from supplied public event URLs.

- **URL**: https://apify.com/automation-lab/gametime-event-tickets-prices.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.66 / 1,000 event ticket snapshots

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

## Gametime Event Tickets Scraper

Export **Gametime event tickets** as repeatable event snapshots with ticket offers, section, row, displayed per-ticket prices including fees, selected quantity and observation time. Supply public event URLs to compare the same markets across repeated runs.

One dataset row represents one event snapshot. Its `offers` array contains the available ticket listings for your selected quantity. This is not a purchase tool, historical database or event discovery engine.

### Who is it for?

Ticket-market analysts can refresh a known watchlist. Event teams can compare seating sections and price levels. Data engineers can join repeated observations by `eventId` and `offerId` in their own warehouse.

### Why use it?

- Keep event identity, venue and price observations together.
- Compare per-ticket amounts for the same ticket quantity rather than mixing order sizes.
- Preserve explicit fee basis and currency.
- Know when an offer cap truncates the result.
- Pay per event snapshot, not separately for each offer inside it.

### Getting started

1. Open a public event on gametime.co.
2. Copy its full URL ending `/events/` followed by the event ID.
3. Add it to `eventUrls` and select a quantity from 1 to 6.
4. Run the Actor and inspect `offerCount`, `availableOfferCount` and `truncated`.
5. Download JSON from the default dataset. Nested offers are best consumed as JSON or flattened downstream for spreadsheet analysis.

### Input

| Parameter | Default | Meaning |
| --- | --- | --- |
| `eventUrls` | Required | 1–20 full HTTPS gametime.co event URLs; no search/category URLs or listing-detail URLs |
| `quantity` | 2 | Exact ticket quantity requested for all events, from 1 to 6 |
| `maxItems` | 20 | Global cap on event snapshots, 1–20, in input order |
| `maxOffers` | 1000 | Per-event included-offer cap, 1–10000 |

Duplicate canonical URLs are processed once. URL queries and fragments are rejected; use the quantity field instead. Zero and unlimited limits are unsupported. No account, cookies, proxy or purchasing credentials are needed or accepted.

```json
{
  "eventUrls": ["https://gametime.co/nfl-football/nfl-international-series-vikings-at-49-ers-tickets/11-22-2026-rsula-coapa-estadio-azteca/events/6995f0fc3beb9acbba056525"],
  "quantity": 2,
  "maxItems": 1,
  "maxOffers": 1000
}
```

Replace the example with a currently active event when its date passes.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `eventId`, `eventName`, `eventUrl` | Event identity and supplied canonical URL |
| `venue`, `city`, `country` | Venue information from the public event page |
| `eventTime` | Source startDate string; may omit timezone information |
| `currency` | Currency code from the event page |
| `selectedQuantity` | Quantity requested for this snapshot |
| `observedAt` | UTC time of observation |
| `offerCount` | Included offers |
| `availableOfferCount` | Eligible unique offers returned by the source |
| `truncated` | True if maxOffers removed any eligible offers |
| `offers[].offerId`, `offerUrl` | Listing identity and public link |
| `offers[].section`, `row`, `sectionGroup` | Seating information; row/group can be null |
| `offers[].pricePerTicket` | All-in amount for one ticket, not an order total |
| `offers[].feeBasis` | `includes_fees` |
| `offers[].availableQuantities` | Quantities supported by this listing |

Only listings supporting the selected quantity are retained. Offers follow the source's list ordering, not a promised independent cheapest-first sort. Repeated IDs within an event are deduplicated. The inventory endpoint is fetched in full even when maxOffers is small.

### Example output

This abbreviated example reflects a live NFL observation; prices and inventory change. The omitted offers are not part of this illustration.

```json
{
  "eventId": "6995f0fc3beb9acbba056525",
  "eventName": "NFL International Series: Minnesota Vikings at San Francisco 49ers",
  "venue": "Estadio Azteca",
  "city": "Úrsula Coapa",
  "country": "MX",
  "eventTime": "2026-11-23T01:20:00",
  "currency": "USD",
  "selectedQuantity": 2,
  "observedAt": "2026-10-26T15:10:00.000Z",
  "offerCount": 1,
  "availableOfferCount": 106,
  "truncated": true,
  "offers": [{
    "section": "525",
    "row": "10",
    "sectionGroup": "Upper",
    "pricePerTicket": 483,
    "feeBasis": "includes_fees",
    "availableQuantities": [2]
  }]
}
```

### Price interpretation

Prices are source all-in inventory prices converted from integer cents to currency units. They include the source's displayed fee basis, but are not a checkout quote or a separately calculated tax/fee breakdown. We do not reserve seats, open a cart or verify final checkout totals. Multiplying by quantity gives an indicative order amount, not a guaranteed purchasable total.

Event time is retained exactly as supplied. If an offset is absent, do not assume the string is local time or UTC. Check the event page before converting timezones or planning attendance.

### How much does it cost to export Gametime event ticket snapshots?

The run has a $0.00005 start event. Each returned event snapshot costs $0.00276 on BRONZE, including its offers array. FREE is $0.003174, SILVER $0.0021528, and GOLD, PLATINUM and DIAMOND $0.001656 per snapshot.

At BRONZE, one snapshot costs $0.00281; five cost $0.01385; twenty cost $0.05525. These are Actor event charges; refer to your Apify plan for any account-level charges. Offers inside a snapshot have no separate event charge. A successfully observed empty inventory is still a billable event snapshot. Invalid input fails before charging the start event. A later failure may leave earlier charged snapshots as partial output.

### Limits and failure behavior

This Actor accesses only public event metadata and current inventory. It excludes purchasing, account data, broad event discovery, historical backfill and built-in change alerts. Scheduling repeated runs creates new observations; it does not reconstruct past prices.

A real zero-offer response produces a snapshot with `offerCount: 0`. Challenge pages, missing metadata, wrong inventory quantity and malformed records fail the run rather than becoming false empty success. A failure stops remaining events; earlier results are partial. Check run status before treating a watchlist as complete.

Requests are sequential with at most two retries for transient network failures, 429 and 5xx. There is no automatic residential fallback. Source availability, listing order and displayed prices may vary over time. Unavailable events can fail metadata validation.

### Integrations

Use an Apify Schedule for recurring watchlist refreshes. Store each run's `observedAt` alongside event and offer IDs in a warehouse; compare only matching currency and selectedQuantity. Join by offerId to identify price movement, and use event-level counts to see inventory changes. Listings missing from a capped snapshot are not proof of sale.

Connect successful-run webhooks to Make, n8n or Zapier to retrieve the dataset and forward it to your spreadsheet or database. Flatten `offers` downstream when one row per ticket listing is needed. Keep the event identity and observation time on every flattened row.

### API use

Use an Apify token stored in your environment, not in shared URLs.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~gametime-event-tickets-prices/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' --data-binary @input.json
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gametime-event-tickets-prices').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/gametime-event-tickets-prices').call(run_input=actor_input)
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items
```

### MCP setup

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/gametime-event-tickets-prices"
```

For Claude Desktop, Cursor, and VS Code clients supporting remote HTTP MCP:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/gametime-event-tickets-prices"
    }
  }
}
```

Discover the actual tools and schemas with scoped `tools/list`. Actor selection also includes run/data tools; discovery does not authorize execution. Example prompt: “With my permission, snapshot these Gametime event URLs for two tickets and show section-level price comparisons.”

Start once and retain the run ID and storage IDs: those are metadata, not results. If the run is nonterminal, check the same run with bounded 2/4/8-second backoff capped at 10 seconds and a 120-second overall deadline. A timeout is not a reason to launch a duplicate run. At the deadline report the pending run ID. Failed runs contain partial data, not a complete watchlist.

After success, retrieve untransformed dataset JSON with explicit limit, offset and fields. A suitable consumer budget is 20 source snapshots per page, at most 100 source rows and 64 KiB serialized UTF-8 across all pages, whichever comes first. Enforce bytes host-side before model injection; offers arrays can make even one row large. If interception is unavailable, do not promise a hard byte bound. Report truncation and next source offset; full exports stay outside model context. This consumer budget does not reduce Actor collection limits.

### Troubleshooting and FAQ

**Why are there fewer offers than on another run?** Quantity affects eligibility, and inventory changes. Compare selectedQuantity, timestamps and truncation flags first.

**Why is a URL rejected?** Use the complete HTTPS gametime.co event URL, not a listing, search or category URL. Remove query strings and fragments.

**Can this buy or reserve tickets?** No. It only observes public inventory.

**Can it monitor automatically?** Schedule it in Apify and implement comparison or alerts downstream. There is no built-in historical store or alert service.

**Does a missing listing mean it sold?** Not necessarily; inventory, ordering, caps and source changes can all remove an offer from a snapshot.

### Legality and responsible use

Review Gametime's terms and applicable law before collecting or redistributing data. Use reasonable refresh intervals and public event URLs only. This Actor is independent and is not endorsed by Gametime.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Do not submit private data in event URLs.

Runtime extraction uses no AI. Public event URLs are sent to Gametime to retrieve public metadata and inventory; payment details, account records and ticket-holder identities are not collected. Apify stores inputs, outputs and logs under your account's retention settings (31 days on our current plan); delete run datasets and key-value stores through Apify when no longer needed. No cross-run session or inventory cache is kept. Infrastructure and diagnostics are company-paid with no separate supplier charge.

For bugs or how-to questions, open an issue on this Actor's Apify page. Include a public event URL, quantity and run link, but no secrets or payment information.

### Related workflows

For another ticket marketplace, see [Vivid Seats Events & Ticket Listings Scraper](https://apify.com/automation-lab/vivid-seats-events-tickets-scraper). Cross-market comparisons require your own event matching and consistent quantity/currency/fee interpretation; this Actor does not perform automatic matching.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/gametime-event-tickets-prices/changelog.md

# Actor input Schema

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

Supply 1–20 full HTTPS gametime.co event URLs ending /events/EVENT_ID. No discovery, listing-detail URLs, queries or fragments. Duplicate event URLs are processed once, in input order.

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

Ticket quantity for all events, from 1 to 6; default 2. Only offers supporting this exact quantity are returned. Prices remain per ticket, not order totals.

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

Global cap on event snapshots, 1–20; default 20. Duplicate event URLs count once. Events are processed in input order; later URLs beyond the cap are not visited. Zero/unlimited is unsupported.

## `maxOffers` (type: `integer`):

Per-event cap on included ticket offers, 1–10000; default 1000. Uses source list order after quantity selection and offer-ID deduplication. truncated=true identifies a capped snapshot; availableOfferCount records the full fetched count. This limits output, not upstream fetching; no extra charge per offer.

## Actor input object example

```json
{
  "eventUrls": [
    "https://gametime.co/nfl-football/nfl-international-series-vikings-at-49-ers-tickets/11-22-2026-rsula-coapa-estadio-azteca/events/6995f0fc3beb9acbba056525"
  ],
  "quantity": 2,
  "maxItems": 20,
  "maxOffers": 1000
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per event, with offers array and truncation flags.

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

Saved snapshot count and request, retry and transfer counters.

# 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://gametime.co/nfl-football/nfl-international-series-vikings-at-49-ers-tickets/11-22-2026-rsula-coapa-estadio-azteca/events/6995f0fc3beb9acbba056525"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gametime-event-tickets-prices").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://gametime.co/nfl-football/nfl-international-series-vikings-at-49-ers-tickets/11-22-2026-rsula-coapa-estadio-azteca/events/6995f0fc3beb9acbba056525"] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gametime-event-tickets-prices").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 '{
  "eventUrls": [
    "https://gametime.co/nfl-football/nfl-international-series-vikings-at-49-ers-tickets/11-22-2026-rsula-coapa-estadio-azteca/events/6995f0fc3beb9acbba056525"
  ]
}' |
apify call automation-lab/gametime-event-tickets-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/gametime-event-tickets-prices"
        }
    }
}
```

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/0RaGsv1p3btv36gfv/builds/iH6CYtoZtZ2IKnDDu/openapi.json