TickPick Scraper: Up to 1,000 Free Results a Month (2026)

A thousand event records cost $5.00 on Apify's free plan, providing a direct view into the resale market without hidden buyer fees. Each event record carries 26 fields, including the lowPrice and highPrice ticket values, venue details, and direct purchase links. This scraper allows practitioners to monitor pricing across 60+ cities and 90 categories including major sports leagues and concert genres. It is built for developers creating price-drop alerts or inventory trackers for secondary markets. It is not for users who need individual seat-map coordinates or specific row and seat numbers, as the event-level records do not include them.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open TickPick Scraper on Apify and run the prefilled example.

How reliable is TickPick Scraper in production?

Across the last 30 days of public runs on the Apify platform, TickPick Scraper recorded 94 runs with the following outcomes.

No run failed or timed out in the last 30 days. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run TickPick 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.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The maxItems control is the primary driver of your bill, as it sets the ceiling for the per-result charge. To minimize costs while testing your integration, use the default limit of 50 to keep the result charge at $0.25 before scaling to larger queries. Using the mode=byCategory with enrichEvents enabled will significantly increase the volume of results and the total cost compared to single-performer lookups.

How do you run TickPick Scraper from the API?

The schema marks 1 of its 11 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~tickpick-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"byCity","citySlug":"new-york","category":"mlb","performerSlugs":["boston-red-sox"],"venueSlugs":["madison-square-garden"],"enrichEvents":false,"maxItems":50}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "byCity",
  "citySlug": "new-york",
  "category": "mlb",
  "performerSlugs": [
    "boston-red-sox"
  ],
  "venueSlugs": [
    "madison-square-garden"
  ],
  "enrichEvents": False,
  "maxItems": 50
}

run = client.actor("crawlerbros~tickpick-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": "byCity",
  "citySlug": "new-york",
  "category": "mlb",
  "performerSlugs": [
    "boston-red-sox"
  ],
  "venueSlugs": [
    "madison-square-garden"
  ],
  "enrichEvents": false,
  "maxItems": 50
}

const run = await client.actor('crawlerbros~tickpick-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 TickPick Scraper inputs matter, and which can you skip?

The mode selector is the most important control, as it determines whether you are targeting a specific location, a performer, or an entire venue. Most users should start with byCity to understand the breadth of available data before using performerSlugs for targeted tracking of specific teams.

• mode (string): What to fetch. Default: "byCity".
• citySlug (string): City to browse upcoming live events in. Default: "new-york".
• category (string): TickPick event category / league. Default: "mlb".
• performerSlugs (array): TickPick performer/team URL slugs within the chosen category, e.g. boston-red-sox, taylor-swift. Find slugs via mode=byCategory. Default: ["boston-red-sox"].
• venueSlugs (array): TickPick venue URL slugs, e.g. madison-square-garden, angel-stadium. Default: ["madison-square-garden"].
• enrichEvents (boolean): When browsing a category, additionally fetch upcoming events (with pricing) for each matched performer/team. Slower - bounded by Max items. Default: false.
• dateFrom (string): ISO date (YYYY-MM-DD). Drop events before this date.
• dateTo (string): ISO date (YYYY-MM-DD). Drop events after this date.
• minPrice (integer): Drop events whose lowest available price is below this.
• maxPrice (integer): Drop events whose lowest available price is above this.
• maxItems (integer): Hard cap on emitted records. Default: 50.

Fixed-choice controls: mode accepts byCity (Browse events by city), byPerformer (Browse events by performer/team), byVenue (Browse events by venue), byCategory (Browse performers/teams by category); citySlug accepts 60 values (default new-york), including new-york (New York), anaheim, arlington, atlanta; category accepts 90 values (default mlb), including mlb, 50s-60s-era (50s 60s Era), adult, alternative.

What does TickPick Scraper return?

The returned records are excellent for market price analysis because TickPick includes all buyer fees in the listed prices, making the lowPrice field a true reflection of the market floor. The output does not contain detailed seller notes or specific row-level inventory, focusing instead on the event-level availability and price range.

Output per event (recordType: "event")

• eventId - TickPick's numeric event ID
• eventName, eventDescription, eventImage
• startDate, endDate, eventStatus, eventAttendanceMode (Offline / Online / Mixed)
• venueName, venueUrl, venueCity, venueState, venueCountry
• performers[], homeTeam, awayTeams[] (sports events)
• lowPrice, highPrice, price, priceCurrency, availability
• ticketUrl - direct link to buy on TickPick
• sourceUrl - canonical event page URL
• category - league/category used for the lookup (if applicable)
• recordType: "event", scrapedAt

Output per performer directory entry (recordType: "performer", mode=byCategory)

• performerName, performerSlug, category
• performerDescription, performerImage (when enrichEvents is on)
• sourceUrl
• recordType: "performer", 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 TickPick 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. Select a scraping strategy by setting the mode to byCity, byPerformer, byVenue, or byCategory.
2. If using byCity, choose a specific citySlug from the dropdown to define the geographical scope.
3. Define a date range using dateFrom and dateTo in YYYY-MM-DD format to isolate specific games or concert tours.
4. Set price floors or ceilings using minPrice and maxPrice to filter out VIP packages or sold-out placeholders.
5. If using byCategory mode, toggle enrichEvents to true if you need to fetch specific event schedules for every team or artist found.
6. Set the maxItems limit to a small value like 10 for a test run to verify the schema of the returned event records.
7. Review the final dataset in the Apify Console, ensuring the lowPrice and highPrice fields contain the expected no-fee values.
8. Download the results as JSON or CSV once you confirm the eventId and venueName fields are populated correctly.

How do you apply it? Three worked playbooks

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

Use case 1: Price tracking

Outcome: Monitor no-fee low/high prices for a team's home games

Configure: Set mode to "byPerformer", category to "mlb", performerSlugs to ["boston-red-sox"], and maxItems to 100.

Working method: Execute the run on a schedule to capture the price field at different intervals before game day. Compare the current lowPrice against previous runs to identify market trends for home games.

Deliverable: A historical dataset of pricing fluctuations for a specific team's schedule, showing price movements over time.

Stop condition: The runner returns zero results for a valid performer slug, indicating the season has ended or the slug has changed.

Use case 2: Event discovery

Outcome: Build a local "what's on" feed for a city

Configure: Set mode to "byCity", citySlug to "new-york", and maxItems to 200.

Working method: Run the scraper weekly using the citySlug for your target market. Use the eventName and startDate fields to populate a local calendar or notification service.

Deliverable: A list of upcoming local events including venueCity, eventImage, and ticketUrl for direct purchasing.

Stop condition: The citySlug enum no longer matches the target city or the output contains events only from a different region.

Use case 3: Venue analytics

Outcome: Compare pricing across events at the same venue

Configure: Set mode to "byVenue", venueSlugs to ["madison-square-garden"], and maxItems to 500.

Working method: Retrieve all records for a specific venue slug and group the output by category. Calculate the average lowPrice across different entertainment types at the same location.

Deliverable: An analytical report comparing the entry-level ticket costs for different sports leagues and concert genres at a single venue.

Stop condition: The venueUrl field in the output records points to a different venue than the one requested in the input slugs.

What breaks, and how do you design around it?

• Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

The scraper is capped at 2,000 records per run, which may require you to split broad category searches into multiple runs by city or date range. If you find a category returns zero performers, switch to mode=byPerformer and provide the slug directly to bypass menu-based discovery limitations.

When should you not use TickPick Scraper?

Do not use this Actor if you require granular seat-level data like specific row and section inventory, as it is designed for event-level price monitoring. If you need data from different marketplaces to compare across platforms, Vivid Seats Ticket Marketplace Scraper or StubHub Ticket Marketplace Scraper may provide better coverage for specific exclusive listings. If your project requires high-frequency polling of the same few events, an official API integration is often more efficient than a public-facing scraper. For projects specifically targeting the Canadian or US mobile-first ticket market with 'from-price' focus, the Gametime Ticket Marketplace Scraper is a more specialized alternative.

What should you check before trusting the output?

• Check for the presence of lowPrice; some sold-out or experience-only listings omit this field entirely.
• Verify that eventStatus is 'active' before processing pricing for automated price-drop alerts.
• Confirm that recordType is 'event' when calculating venue averages, as byCategory mode can return 'performer' records.
• Monitor the availability field to ensure your downstream application does not list events that no longer have tickets.
• Validate that the scrapedAt timestamp is recent enough for high-volatility resale market analysis.

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

Frequently asked questions

What is the expected reliability for automated ticket monitoring?

The data shows that 94 of 94 public runs in the last 30 days finished successfully, representing a 100.0% success rate. This indicates high consistency for unattended scheduling. Since no runs failed or timed out during this period, you can expect stable performance when tracking daily price changes for major events.

How much does it cost to monitor an entire sports league?

On the free-plan price of $5.00 per 1,000 results, scraping a full league's upcoming games is very affordable. A typical run returning 200 results would cost roughly $1.00 in result charges. Keep in mind that Apify also bills for the platform usage consumed during the run in addition to the per-result fee.

Can I test the scraper for free?

Yes, Apify's free plan includes $5.00 of monthly usage without requiring a credit card. This is enough to cover up to 1,000 results of this Actor. The provided example input uses a maxItems cap of 50, which ensures your very first run costs at most $0.25 in result charges while you verify the output.

Why are some ticket prices missing from the event results?

Pricing fields like lowPrice or highPrice are omitted by the scraper if TickPick does not provide an 'offers' block on the page. This typically happens for sold-out events or informational listings. The Actor omits these empty fields entirely rather than returning null or zero values to keep the dataset clean.

How do I find the correct slugs for a specific performer?

You should use mode=byCategory first to discover the exact performerSlugs for a given category. Because TickPick nests performers under league prefixes, like /mlb/boston-red-sox-tickets/, you cannot always guess the slug. Once you have the slug from a category discovery run, you can use mode=byPerformer for direct tracking.

Where to go next

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

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

Other Actors we maintain for related data:

• Vivid Seats Ticket Marketplace Scraper: Scrape live event listings from Vivid Seats - concerts, sports, and theater tickets.
• Gametime Ticket Marketplace Scraper: Scrape live event listings from Gametime - concerts, sports, and theater tickets.
• SeatGeek Scraper: Scrape SeatGeek - search live event listings by artist, team, or venue, or browse 156 sports/concert/theater categories.
• StubHub Ticket Marketplace Scraper: Scrape StubHub.com event listings by keyword, artist, team, venue, or category.

Related guides:

• FlashScore Live Sports Scraper: 3 Practical Use Cases
• Eventbrite Events Scraper: Up to 2,500 Free Results a Month (2026)
• TikTok LIVE Event Stream Scraper: 3 Operational Playbooks
• Facebook Events Scraper: Practical Use Cases and Workflows
• Meetup + Lu.ma Events Scraper: 17 Data Fields per Record (2026)
• The RealReal Scraper: Up to 1,000 Free Results a Month (2026)

Resources

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

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

• Run outcome figures cover the 30 day public window ending 2026-09-29.

• TickPick Scraper on Apify