# Gametime Ticket Marketplace Scraper (`crawlerbros/gametime-scraper`) Actor

Scrape live event listings from Gametime - concerts, sports, and theater tickets. Browse by performer/team/venue name, by US/Canada metro area, or by category, with date range filtering and live from-price data.

- **URL**: https://apify.com/crawlerbros/gametime-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

## Gametime Scraper

Scrape **Gametime** — a US/Canada ticket resale marketplace for concerts, sports, and theater. Browse events by performer, team, or venue name, by metro area, or by category, with date-range filtering and live "from $X" pricing. No login, no API key, no residential proxy required.

### What this actor does

- **Three modes:** `byCategory` (concerts / sports / theater), `search` (performer, team, or venue name), `byCity` (any of Gametime's 78 US/Canada metro areas)
- **Date range filter** works across every mode
- **Live pricing:** minimum and maximum ticket price per event
- **Full venue detail:** name, city, state, country, coordinates, and venue page URL
- **Empty fields are omitted** — every record only contains fields that were actually available

### Output per event

- `eventId` — Gametime internal event ID
- `name` — event title
- `localDateTime` — event start date/time in the venue's local timezone
- `eventDate` — event date (`YYYY-MM-DD`), used for date-range filtering
- `utcDateTime` — event start in UTC
- `dateTbd`, `timeTbd` — true if the date/time is not yet confirmed
- `category` — Gametime's specific sub-category (e.g. `nfl`, `music`, `pga`)
- `categoryGroup` — `Concerts` / `Sports` / `Theater`
- `performers[]` — every performer/team/artist billed on the event
- `performerImageUrl` — hero image of the primary performer
- `genres[]` — genre tags for the primary performer (concerts), when available
- `venueName`, `venueAddress`, `venuePostalCode`, `venueCity`, `venueState`, `venueCountry`
- `venueUrl` — Gametime venue page
- `venueLatitude`, `venueLongitude`
- `venueImageUrl` — venue/seating image
- `minPrice`, `maxPrice` — ticket price range (USD)
- `flashDealPrice` — limited-time discounted price, when Gametime is running one
- `eventUrl` — Gametime event/ticket page
- `recordType: "event"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `byCategory` / `search` / `byCity` |
| `searchQuery` | string | `New York Yankees` | Performer, team, or venue name (mode=search) |
| `city` | string | `newyork` | One of Gametime's 78 supported metro areas (mode=byCity) |
| `category` | string | `concerts` | `concerts` / `sports` / `theater` (mode=byCategory) |
| `dateFrom` | string | – | Only events on/after this date (`YYYY-MM-DD`), all modes |
| `dateTo` | string | – | Only events on/before this date (`YYYY-MM-DD`), all modes |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |
| `proxyConfiguration` | object | AUTO | Optional Apify proxy; not required |

#### Example: browse concerts

```json
{
  "mode": "byCategory",
  "category": "concerts",
  "maxItems": 50
}
````

#### Example: browse sports in a date range

```json
{
  "mode": "byCategory",
  "category": "sports",
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "maxItems": 100
}
```

#### Example: search by team

```json
{
  "mode": "search",
  "searchQuery": "New York Yankees",
  "maxItems": 30
}
```

#### Example: browse by metro area

```json
{
  "mode": "byCity",
  "city": "lasvegas",
  "maxItems": 50
}
```

### Use cases

- **Ticket price tracking** — monitor "from $X" prices over time for an artist, team, or venue
- **Event calendars** — build a local events feed for a metro area
- **Market research** — compare price ranges across venues or categories
- **Fan tools** — alert on new upcoming shows for a favorite performer or team
- **Venue analytics** — track upcoming event volume at a specific venue

### Data Source / Limitations

Data comes from Gametime's public mobile-app API (gametime.co) — no login or account is required to view listings. `search` resolves a free-text name to the single best-matching performer, team, or venue on Gametime; if a query has no match, the actor returns 0 records with a clear status message instead of guessing. `byCity` uses Gametime's own curated list of 78 US/Canada metro areas — smaller markets not on that list aren't individually addressable. Gametime only lists **upcoming** events — a `dateTo` in the past will always return 0 records, since past events are never listed.

### FAQ

**Is this affiliated with Gametime?**
No. This is an independent, third-party actor that reads Gametime's public API. It is not affiliated with, endorsed by, or sponsored by Gametime.

**Why does `search` sometimes return 0 records for a name I know is on Gametime?**
Two reasons: (1) the performer/team/venue has no upcoming events listed right now — ticket marketplaces only carry future events, so an artist between tours will show 0; (2) the name didn't resolve to a match on Gametime. Try the exact name as it appears on gametime.co.

**Why is my city not in the `city` dropdown?**
Gametime organizes browsing around 78 curated metro areas (major US and Canadian markets) rather than every individual city. Pick the nearest metro area from the dropdown, or use `search` with a specific team/venue name instead.

**Do I need a proxy?**
No. The actor works reliably without any proxy configuration. An optional Apify AUTO (datacenter) proxy can be enabled for extra IP diversity, but it is not required and no paid/residential proxy is ever needed.

**How fresh is the pricing data?**
Prices reflect live resale marketplace listings at the time the actor runs — they change frequently as tickets are bought and sold.

**Are prices in USD?**
Yes, all price fields are in US dollars.

**Can I filter by date range and category/performer/city at the same time?**
Yes — `dateFrom`/`dateTo` apply on top of whichever mode you choose.

**What happens if I request more items than exist?**
The actor returns as many real records as exist (up to `maxItems`) and stops — it never fabricates placeholder records.

# Actor input Schema

## `mode` (type: `string`):

What to browse.

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

Name of an artist, sports team, or venue, e.g. `Taylor Swift`, `New York Yankees`, `Madison Square Garden`.

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

US/Canada metro area recognized by Gametime.

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

Gametime's top-level event category.

## `dateFrom` (type: `string`):

Only include events on or after this date (`YYYY-MM-DD`). Applies to every mode.

## `dateTo` (type: `string`):

Only include events on or before this date (`YYYY-MM-DD`). Applies to every mode.

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

Hard cap on emitted event records.

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

Optional. Gametime's public mobile API works reliably without any proxy. An Apify AUTO (datacenter) proxy can be enabled for extra IP diversity, but it is not required.

## Actor input object example

```json
{
  "mode": "byCategory",
  "searchQuery": "New York Yankees",
  "city": "newyork",
  "category": "concerts",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset containing all scraped Gametime event listings.

# 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 = {
    "mode": "byCategory",
    "searchQuery": "New York Yankees",
    "city": "newyork",
    "category": "concerts",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gametime-scraper").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 = {
    "mode": "byCategory",
    "searchQuery": "New York Yankees",
    "city": "newyork",
    "category": "concerts",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gametime-scraper").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 '{
  "mode": "byCategory",
  "searchQuery": "New York Yankees",
  "city": "newyork",
  "category": "concerts",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/gametime-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/gametime-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gametime Ticket Marketplace Scraper",
        "description": "Scrape live event listings from Gametime - concerts, sports, and theater tickets. Browse by performer/team/venue name, by US/Canada metro area, or by category, with date range filtering and live from-price data.",
        "version": "1.0",
        "x-build-id": "PAIhAfngFrWfn5cGf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gametime-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gametime-scraper",
                "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/crawlerbros~gametime-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gametime-scraper",
                "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/crawlerbros~gametime-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gametime-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "search",
                            "byCity"
                        ],
                        "type": "string",
                        "description": "What to browse.",
                        "default": "byCategory"
                    },
                    "searchQuery": {
                        "title": "Performer, team, or venue name (mode=search)",
                        "type": "string",
                        "description": "Name of an artist, sports team, or venue, e.g. `Taylor Swift`, `New York Yankees`, `Madison Square Garden`.",
                        "default": "New York Yankees"
                    },
                    "city": {
                        "title": "Metro area / city (mode=byCity)",
                        "enum": [
                            "albuquerque",
                            "atlanta",
                            "austin",
                            "baltimore",
                            "bigsky",
                            "birmingham",
                            "blacksburg",
                            "boise",
                            "boston",
                            "buffalo",
                            "calgary",
                            "charlotte",
                            "chicago",
                            "cincinnati",
                            "cleveland",
                            "colorado",
                            "columbia",
                            "columbus",
                            "dallas",
                            "detroit",
                            "edmonton",
                            "elpaso",
                            "fayetteville",
                            "fresno",
                            "grandrapids",
                            "hartford",
                            "honolulu",
                            "houston",
                            "indianapolis",
                            "international",
                            "iowacity",
                            "jackson",
                            "jacksonville",
                            "kansascity",
                            "knoxville",
                            "lasvegas",
                            "lexington",
                            "littlerock",
                            "losangeles",
                            "louisville",
                            "lubbock",
                            "memphis",
                            "miami",
                            "milwaukee",
                            "minneapolis",
                            "montreal",
                            "morgantown",
                            "nashville",
                            "neworleans",
                            "newyork",
                            "oklahomacity",
                            "omaha",
                            "orlando",
                            "ottawa",
                            "philadelphia",
                            "phoenix",
                            "pittsburgh",
                            "portland",
                            "providence",
                            "puertorico",
                            "raleigh",
                            "reno",
                            "richmond",
                            "sacramento",
                            "saltlakecity",
                            "sanantonio",
                            "sandiego",
                            "sanfrancisco",
                            "seattle",
                            "stlouis",
                            "syracuse",
                            "tallahassee",
                            "tampabay",
                            "toronto",
                            "tucson",
                            "vancouver",
                            "washingtondc",
                            "winnipeg"
                        ],
                        "type": "string",
                        "description": "US/Canada metro area recognized by Gametime.",
                        "default": "newyork"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "concerts",
                            "sports",
                            "theater"
                        ],
                        "type": "string",
                        "description": "Gametime's top-level event category.",
                        "default": "concerts"
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Only include events on or after this date (`YYYY-MM-DD`). Applies to every mode."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Only include events on or before this date (`YYYY-MM-DD`). Applies to every mode."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted event records.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Gametime's public mobile API works reliably without any proxy. An Apify AUTO (datacenter) proxy can be enabled for extra IP diversity, but it is not required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
