SeatGeek Scraper: 38 Data Fields, Up to 1,000 Free Results/Month

Each record carries 38 output fields, capturing live ticket counts, pricing distributions, and venue coordinates directly from SeatGeek event pages. At $5.00 per 1,000 results on the free plan, you can monitor resale pricing across 156 sports, concert, and theater categories without maintaining browser pools or manual scraper infrastructure. It can be tried free. This Actor is built for analytics teams and secondary ticket aggregators tracking market-level pricing spreads. It is not for anyone who needs individual row-level seat selections, specific seat numbers, or SeatGeek Deal Score badges, which the records do not include.

Try it: open SeatGeek Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try SeatGeek Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of SeatGeek Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

SeatGeek Scraper was last updated on 2026-07-21. It is one of 1,729 Actors CrawlerBros publishes on Apify, which together have 746,619 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run SeatGeek Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems setting is the single input control that directly dictates your result charges by capping dataset emission. Keep maxItems capped at 20 on your initial test run to verify field coverage for under ten cents before widening extractions across full categories.

How do you run SeatGeek Scraper from the API?

The schema marks 1 of its 13 controls as required: mode. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~seatgeek-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","searchQuery":"New York Yankees","category":"nba","startUrls":[{"url":"https://seatgeek.com/nfl-tickets"}],"sortBy":"relevance","maxItems":20,"proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "search",
  "searchQuery": "New York Yankees",
  "category": "nba",
  "startUrls": [
    {
      "url": "https://seatgeek.com/nfl-tickets"
    }
  ],
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~seatgeek-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "search",
  "searchQuery": "New York Yankees",
  "category": "nba",
  "startUrls": [
    {
      "url": "https://seatgeek.com/nfl-tickets"
    }
  ],
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

const run = await client.actor('crawlerbros~seatgeek-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which SeatGeek Scraper inputs matter, and which can you skip?

The mode control determines how the scraper discovers events, switching the operational context between searchQuery, category, and direct startUrls. Most users running their initial tests should leave the proxyConfiguration alone and avoid setting minPrice or maxPrice until they confirm baseline inventory volume.

• mode (string): What to scrape. Default: "search".
• searchQuery (string): Name of an artist, sports team, or venue, e.g. New York Yankees, Coldplay, Madison Square Garden. Default: "New York Yankees".
• category (string): A SeatGeek event category - sports league, music genre, or entertainment type. Default: "nba".
• startUrls (array): Direct seatgeek.com URLs to fetch - category pages (/nba-tickets), performer pages (/coldplay-tickets), or venue pages (/venues/madison-square-garden-tickets).
• sortBy (string): How to order the emitted results. Default: "relevance".
• maxItems (integer): Hard cap on emitted event records. Default: 20.
• proxyConfiguration (object): Optional. SeatGeek is protected by a bot-detection layer that blocks plain datacenter requests without a browser-matching TLS fingerprint; the actor already handles this in code with no proxy required. The free Apify AUTO proxy group is used automatically as a fallback only if a request is ever blocked. Default: {"useApifyProxy":true}.
• dateFrom (string): Only include events on or after this date (YYYY-MM-DD). Applies to every mode.
• dateTo (string): Only include events on or before this date (YYYY-MM-DD). Applies to every mode.
• minPrice (integer): Only include events whose lowest listed ticket price is at least this amount.
• maxPrice (integer): Only include events whose lowest listed ticket price is at most this amount.
• city (string): Only include events at a venue in this city, e.g. Chicago. Exact match, case-insensitive.

The other 1 controls, with their defaults, are listed in the input schema on SeatGeek Scraper on Apify.

Fixed-choice controls: mode accepts search (Search by artist, team, or venue name), byCategory (Browse by category (sport / genre / league)), byUrl (Fetch specific SeatGeek URLs); category accepts 156 values (default nba), including nba, af1, ahl, american-association (American Association); sortBy accepts relevance (SeatGeek's own order), date (Event date (soonest first)), priceLow (Price (lowest first)), priceHigh (Price (highest first)), popularity (most popular first).

What does SeatGeek Scraper return?

The output provides event-level metrics including priceMin, priceAverage, listingCount, and full venue geolocation coordinates suitable for schedule aggregation. It intentionally does not provide individual seat numbers, row breakdowns, section maps, or per-ticket Deal Scores.

• eventId, eventTitle
• eventDate (YYYY-MM-DD), eventDateTimeLocal, eventDateTimeUtc, dateTbd
• venueName, venueAddress, venueCity, venueState, venueCountry, venuePostalCode, venueCapacity
• venueLatitude, venueLongitude, venueTimezone, venueUrl
• performers[], primaryPerformer
• category, categorySlug
• priceMin, priceMax, priceAverage, priceMedian, currency
• listingCount, ticketCount
• thumbnailUrl
• isOpen, isRescheduled, eventStatus, announceDate
• popularityScore (SeatGeek's own 0-1 popularity ranking for the event)
• listingUrl, sourceUrl
• recordType: "event", scrapedAt

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open SeatGeek Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run once with mode set to search and searchQuery set to New York Yankees with maxItems capped at 1 to confirm connectivity.
2. Verify the output contains eventId, eventTitle, and non-null priceMin and priceMax values.
3. Switch mode to byCategory or byUrl depending on whether you are querying a broad league or targeting a specific venue.
4. Set dateFrom and dateTo using strict YYYY-MM-DD formatting to bound the event window and eliminate off-season records.
5. Apply minPrice or maxPrice integer thresholds if your workflow specifically filters out luxury suites or standing-room-only inventory.
6. Inspect venueLatitude, venueLongitude, and venueTimezone to ensure downstream geolocation pipelines receive valid venue coordinates.
7. Increase maxItems up to your target batch size, keeping in mind SeatGeek caps initial server-rendered listings per page.

How do you apply it? Three worked playbooks

These are SeatGeek Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Ticket price tracking

Outcome: Monitor lowest-price trends for a team, artist, or venue

Configure: Set mode to search, searchQuery to New York Yankees, and maxItems to 50.

Working method: Execute a baseline extraction for the target team to capture current priceMin and priceMedian levels across upcoming fixtures, then establish a daily schedule to detect price shifts as match dates approach.

Deliverable: A tabular time series tracking eventId, eventDate, priceMin, and ticketCount over time.

Stop condition: The query returns an empty dataset because the team has entered the off-season or the slug failed to resolve.

Use case 2: Event discovery

Outcome: Build a feed of upcoming events in a category, city, or state

Configure: Set mode to byCategory, category to concerts, state to NY, and sortBy to date.

Working method: Run across the target region with a bounded dateFrom window, parsing newly announced fixtures and mapping venue coordinates directly into local listing feeds.

Deliverable: A structured event feed JSON containing eventTitle, venueName, venueCity, and eventDateTimeLocal.

Stop condition: Output records contain dates outside the requested window or omit venueCity entries.

Use case 3: Market research

Outcome: Compare listing counts and price spreads across categories

Configure: Set mode to byCategory, category to broadway, and sortBy to popularity.

Working method: Extract inventory metrics across multiple entertainment categories sequentially, evaluating aggregate supply using listingCount against the spread between priceMin and priceMax.

Deliverable: A cross-category market report comparing median listing counts and average prices per event.

Stop condition: Aggregate pricing metrics like priceAverage and priceMedian return empty across more than half of the emitted events.

What breaks, and how do you design around it?

• **Individual event page links (listingUrl / sourceUrl) are real, correct
• Per-event ticket counts, not a page-limited count. SeatGeek server-renders a
• No public full-text search API. search mode resolves via SeatGeek's own
• Per-listing "Deal Score" is not included - see the FAQ above for why.
• US marketplace only. This actor reads seatgeek.com. SeatGeek's separate

Individual event URLs in listingUrl cannot be scraped headlessly because SeatGeek protects single-event detail pages with stricter bot detection than aggregate category listings. When category extractions hit the limit of server-rendered listings, partition queries using tighter dateFrom and dateTo windows or regional city filters rather than relying on pagination.

When should you not use SeatGeek Scraper?

Do not use this Actor if your project requires row-level seat tracking, seat-view imagery, or interactive seating charts, because SeatGeek only exposes those on heavily protected checkout endpoints not supported here. If you need ticket inventory on other primary secondary marketplaces, use StubHub Ticket Marketplace Scraper or Vivid Seats Ticket Marketplace Scraper instead. If your pricing models rely strictly on all-in ticket pricing without added checkout fees, switch to TickPick Scraper. Finally, avoid this tool entirely if you need coverage for international non-US events, as it only scrapes seatgeek.com domains.

What should you check before trusting the output?

• Discard or flag records where priceMin is null or missing, indicating an event with no active ticket listings.
• Verify that eventDate adheres strictly to the YYYY-MM-DD pattern before ingestion into time-series tables.
• Halt execution if a scheduled run for an in-season category emits zero items, signalling possible bot-blocking or an invalid category slug.
• Check that listingCount and ticketCount are positive integers whenever priceAverage is present.
• Ensure venueCity and venueState match your targeted regional filter when querying geographic subsets.

None of this proves a record is correct. It gives a scheduled SeatGeek Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does running this Actor cost on Apify's free plan?

Pricing is $0.005 per result, which equals $5.00 per 1,000 results on the free tier. Apify's free plan includes $5.00 of monthly usage with no credit card, covering up to 1,000 results of this Actor before factoring in standard platform usage and run-start fees.

Why does search mode return zero results for my query?

The search mode relies on SeatGeek's canonical SEO URL structure rather than a fuzzy text engine. An ambiguous query, typo, or team currently in its off-season without scheduled games will yield zero results. Use mode set to byUrl with an exact SeatGeek link if a query fails.

Can I fetch individual seat rows and section details?

No. The scraper collects event-level summaries such as priceMin, priceMax, listingCount, and ticketCount from aggregator views. Detailed ticket rows and seating sections live behind SeatGeek's protected inventory endpoints, which this Actor does not target.

Are Canadian or European SeatGeek domains supported?

No. The Actor exclusively extracts data from the primary US marketplace at seatgeek.com. Separate country sites like seatgeek.ca are not covered, so regional queries outside the US catalog will return empty datasets.

Is an external proxy configuration required to bypass blocks?

No. The Actor handles access in code with no proxy required by default, utilizing a browser-matching HTTP client signature. The free Apify AUTO proxy group is built in and used automatically as a fallback only if a request is ever blocked.

Where to go next

When you are ready to run it, open SeatGeek Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the SeatGeek Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Gametime Ticket Marketplace Scraper: Scrape live event listings from Gametime - concerts, sports, and theater tickets.
• Vivid Seats Ticket Marketplace Scraper: Scrape live event listings from Vivid Seats - concerts, sports, and theater tickets.
• TickPick Scraper: Scrape TickPick.com - the no-fee ticket resale marketplace.
• StubHub Ticket Marketplace Scraper: Scrape StubHub.com event listings by keyword, artist, team, venue, or category.

Related guides:

• TickPick Scraper: Up to 1,000 Free Results a Month (2026)
• Eventbrite Events Scraper: Up to 2,500 Free Results a Month (2026)
• FlashScore Live Sports Scraper: 3 Practical Use Cases
• Facebook Events Scraper: Practical Use Cases and Workflows
• Meetup + Lu.ma Events Scraper: 17 Data Fields per Record (2026)
• Woot Scraper: 65 Data Fields, Up to 1,000 Free Results/Month (2026)
• RentHop NYC Apartment Rentals Scraper: 14 Data Fields per Record
• Heritage Auctions Scraper: 20 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-07.

• Actor last updated by its maintainers on 2026-07-21.

• Run outcome figures cover the 30 day public window ending 2026-10-07.

• SeatGeek Scraper on Apify