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.

{
  "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.

{
  "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.

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

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 });

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

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:

{
  "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. Cross-market comparisons require your own event matching and consistent quantity/currency/fee interpretation; this Actor does not perform automatic matching.