TickPick Events & Tickets Scraper

Turn public TickPick pages into structured event and ticket-price data.

Use direct event URLs, discovery pages, or search terms.

Get event IDs, schedules, performers, venues, availability, currencies, and current aggregate low/high prices in one clean dataset.

The Actor is designed for repeatable ticket-market research, event enrichment, and price monitoring without checkout automation or account access.

What does TickPick Events & Tickets Scraper do?

The Actor visits public pages on TickPick and extracts normalized event records.

It supports:

• 🎟️ Direct TickPick event URLs
• 🔎 TickPick search queries
• 🏟️ Venue, performer, city, category, sport, concert, and theater discovery pages
• 💵 Current aggregate low and high ticket prices
• 📍 Venue names and public address fields
• 🎤 Performer names
• 📅 Event start and end times when published
• ✅ Ticket availability and offer-validity timestamps

Discovery pages are followed to event detail pages.

Duplicate event links are merged using the numeric TickPick event ID.

Who is it for?

Ticket-market analysts

Track public price ranges across events and compare changes between scheduled runs.

Event aggregators

Enrich calendars with performers, venue details, images, and source URLs.

Travel and entertainment apps

Add upcoming events near destinations and let users follow the original TickPick page.

Sports researchers

Collect schedules and aggregate ticket-price signals for teams, leagues, and venues.

Data teams

Export consistent JSON, CSV, Excel, XML, or RSS-compatible data from Apify datasets.

Why use this Actor?

TickPick pages are useful to people but awkward to combine at scale.

This Actor converts the public structured information into stable records.

Benefits include:

• ⚡ HTTP-first extraction without a heavy browser runtime
• 🧩 Consistent fields across event types
• 🔁 Repeatable runs for monitoring
• 🛡️ Same-host URL validation
• ♻️ Event-ID deduplication
• 📦 Native Apify datasets and API access
• 🔌 Integrations with webhooks, Make, Zapier, Google Sheets, and cloud storage

What TickPick data can I extract?

Field	Description
eventId	Numeric TickPick event identifier
url	Canonical public TickPick event URL
title	Event title
description	Public event summary when available
eventType	Schema.org event type, such as MusicEvent
eventStatus	Scheduled, cancelled, postponed, or another published status
startTime	Published event start time
endTime	Published event end time when available
performers	List of published performer names
primaryPerformer	First published performer
venueName	Venue name
venueUrl	Public TickPick venue URL
streetAddress	Venue street address
city	Venue city
region	State or region
country	Country code or name
imageUrl	Public event or performer image
availability	Published ticket availability
currency	Price currency, commonly USD
lowPrice	Current aggregate low ticket price
highPrice	Current aggregate high ticket price
priceValidFrom	Beginning of the published price-valid window
priceValidThrough	End of the published price-valid window
scrapedAt	UTC extraction timestamp

Fields absent from the source are omitted instead of filled with misleading values.

How much does it cost to scrape TickPick events?

This Actor uses pay-per-event pricing.

You pay a $0.005 start charge and a charge for each event record produced.

Apify tier	Price per event
Free	$0.00024088
Bronze	$0.00020946
Silver	$0.00016338
Gold	$0.00012568
Platinum	$0.000083785
Diamond	$0.00005865

For example, 100 records cost about $0.0291 on Bronze including the start charge.

The live price appears in the Actor pricing tab before every run and is authoritative.

A five-event test is intentionally available through the input prefill.

To estimate a run:

1. Choose the expected number of events.
2. Multiply it by your plan's displayed record price.
3. Add the displayed one-time start charge.
4. Set maxItems to enforce a hard record limit.

How to scrape TickPick event data

1. Open the Actor input page.
2. Add one or more TickPick URLs, search queries, or both.
3. Set a conservative maxItems value.
4. Leave proxy access disabled unless direct requests are limited.
5. Click Start.
6. Open the Dataset tab when the run finishes.
7. Export the results or access them through the API.

A direct event URL is the fastest way to test one record.

A search query or discovery page is better for collecting several events.

Input options

TickPick URLs

Add public TickPick URLs using the request-list editor.

Supported examples include:

• Event detail pages
• TickPick search pages
• Sports category pages
• Concert and theater pages
• Performer or team pages
• Venue pages
• City discovery pages

Only tickpick.com hosts are accepted.

Search queries

Enter artist, team, venue, city, or event terms.

Each value is sent to TickPick's public search page.

Maximum events

maxItems limits unique saved event records across all inputs.

The default is 25 and the prefilled test uses 5.

Proxy configuration

Direct access is the cheapest default.

Enable Apify Proxy or provide custom proxies if TickPick limits requests from your run location.

Input example

{
  "searchQueries": ["concert"],
  "startUrls": [
    { "url": "https://www.tickpick.com/nfl-tickets/" }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

You may use only searchQueries, only startUrls, or both.

At least one route is required.

Output example

{
  "eventId": "7676474",
  "url": "https://www.tickpick.com/buy-five-finger-death-punch-cody-jinks-eva-under-fire-tickets-the-cynthia-woods-mitchell-pavilion-9-27-26-6pm/7676474/",
  "title": "Five Finger Death Punch, Cody Jinks & Eva Under Fire",
  "eventType": "MusicEvent",
  "eventStatus": "EventScheduled",
  "startTime": "2026-09-27T18:45:00",
  "performers": ["Five Finger Death Punch"],
  "venueName": "The Cynthia Woods Mitchell Pavilion",
  "city": "Spring",
  "region": "TX",
  "country": "US",
  "availability": "InStock",
  "currency": "USD",
  "lowPrice": 29,
  "highPrice": 1259,
  "scrapedAt": "2026-07-16T03:15:00.000Z"
}

Prices are source observations, not purchase quotes or guarantees.

Ticket price monitoring workflow

Run the Actor on a schedule to build a time series.

A practical workflow is:

1. Save stable event or discovery URLs in an Apify task.
2. Schedule the task hourly, daily, or weekly.
3. Keep eventId, lowPrice, highPrice, availability, and scrapedAt.
4. Append each run to a warehouse or spreadsheet.
5. Alert when the low price crosses a threshold.
6. Follow url to verify the live offer before acting.

Offer timestamps help distinguish a current source observation from an old export.

Tips for reliable results

• Start with one direct event URL.
• Use low maxItems values while designing a workflow.
• Prefer specific performer, venue, or category pages over broad searches.
• Schedule repeated monitoring rather than starting many overlapping runs.
• Enable a proxy only after direct access is limited.
• Keep the source URL with every downstream record.
• Treat missing optional values as unavailable at the source.
• Compare prices only when currencies match.

Integrations

Google Sheets

Use the Apify Google Sheets integration to append price snapshots for analyst review.

Make

Trigger the Actor from Make, iterate over dataset items, and route events by city or price.

Zapier

Send newly discovered events to Slack, email, a CRM, or an internal calendar workflow.

Webhooks

Attach a run-succeeded webhook and fetch the default dataset from your backend.

Cloud storage

Export JSON or CSV to Amazon S3, Google Cloud Storage, Azure, or your data warehouse process.

Event calendar enrichment

Join records by eventId, canonical URL, performer, venue, and event time.

API usage with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tickpick-events-tickets-scraper').call({
  searchQueries: ['concert'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Use an environment variable for your Apify token.

API usage with Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tickpick-events-tickets-scraper').call(
    run_input={'searchQueries': ['concert'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

The dataset remains available according to your Apify storage retention settings.

API usage with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tickpick-events-tickets-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["concert"],"maxItems":10}'

Use the returned run and dataset identifiers to retrieve output.

Do not put long-lived tokens into source control.

Use with AI agents via MCP

Connect AI tools through the Apify Model Context Protocol server. The actor-specific endpoint is:

https://mcp.apify.com/?tools=automation-lab/tickpick-events-tickets-scraper

Claude Code setup

$claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/tickpick-events-tickets-scraper"

Authenticate with your Apify account when prompted.

Claude Desktop, Cursor, and VS Code setup

Add this server to the MCP configuration used by Claude Desktop, Cursor, or VS Code:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tickpick-events-tickets-scraper"
    }
  }
}

Example prompts:

• “Use automation-lab/tickpick-events-tickets-scraper to find ten concert events and compare their aggregate low prices.”
• “Extract this TickPick event and summarize the venue and schedule.”
• “Build a table of NFL events with city, availability, and price range.”

Always review live source pages before making purchase or resale decisions.

Error handling and troubleshooting

Why did the run report no events?

The URL may not currently expose event links, the search may have no matching events, or TickPick may have limited the request.

Try one known public event URL first.

Then narrow the query or enable proxy access.

The Actor intentionally fails instead of returning a misleading empty success when every extraction route fails.

Why are some fields missing?

TickPick does not publish every optional field for every event.

The Actor omits unavailable values rather than inventing data.

Why did my external URL fail?

For safety and product consistency, explicit URLs must belong to TickPick.

Why do prices change between runs?

Ticket marketplaces are dynamic.

Use priceValidFrom, priceValidThrough, and scrapedAt when comparing snapshots.

Data quality and limitations

The Actor extracts public aggregate event offers.

It does not:

• Sign in to TickPick
• Buy or reserve tickets
• Automate checkout
• Return seat-level inventory in minimum v1
• Guarantee that a displayed offer remains available
• Convert currencies
• Predict future ticket prices

Source pages and structured markup can change.

Validate important decisions against the linked event URL.

Legality

Scraping public web data can be lawful, but requirements vary by country, purpose, contract, and data type.

You are responsible for your use of the Actor and resulting data.

Review TickPick's terms, applicable laws, database rights, rate limits, and privacy obligations.

Avoid collecting personal data, bypassing access controls, or using output for prohibited activities.

This documentation is not legal advice.

FAQ

Can I scrape one event?

Yes. Supply its public TickPick event URL and set maxItems to 1.

Can I search by artist or team?

Yes. Put the name in searchQueries or provide the relevant TickPick performer or team page.

Does it return exact seats and rows?

No. Minimum v1 focuses on event metadata and public aggregate low/high prices.

Are duplicate events removed?

Yes. Records are deduplicated by TickPick's numeric event ID during each run.

Can I schedule recurring runs?

Yes. Save the input as an Apify task and attach a schedule.

Can I export CSV or Excel?

Yes. Use the dataset export controls or API format parameter.

Does it require a TickPick account?

No. The Actor uses public anonymous event and discovery pages.

Should I enable a residential proxy?

Only if direct requests are consistently limited and your Apify plan permits it.

Related event scrapers

Explore other event workflows from automation-lab:

• Eventbrite Events Scraper
• Bandsintown Events Scraper
• DICE Events Scraper

Combine source-specific actors only after normalizing IDs, URLs, times, currencies, and venue names.

Support

If a valid public TickPick page fails, open an Actor issue with:

• The input used
• The run URL
• The expected event
• Whether proxy access was enabled
• The approximate time of the run

Do not include passwords, account cookies, payment details, or private tokens.