Fever Events Scraper

Discover public Fever events by city, category, date, keyword, or event URL. The Actor turns Fever city and event pages into structured records with stable event IDs, schedules, venues, prices, availability, ratings, images, categories, and canonical URLs.

Use it to build local-event feeds, enrich a known Fever URL, compare city inventories, or schedule recurring snapshots for event monitoring. It reads only public Fever marketplace pages and does not enter checkout, favorites, accounts, or personalized inventory.

What does Fever Events Scraper do?

The Actor supports two extraction routes:

1. Give it a public city, category, or search page such as https://feverup.com/en/new-york to discover event IDs and fetch structured details.
2. Give it one or more public /m/ event URLs to extract those events directly.

Optional text, category, and date filters are applied to normalized event details before a record is saved or charged. Duplicate events discovered from multiple start URLs are emitted once.

The scraper uses Fever's server-rendered public application state. It does not download event images or videos, and it does not need a browser for the current public pages.

Who is it for?

• Event aggregators building city experience catalogs.
• Travel and local-content publishers refreshing things-to-do feeds.
• Market analysts comparing public event supply, dates, venues, and displayed prices.
• Data teams enriching a list of known Fever event URLs.
• Automation teams taking recurring snapshots and comparing stable event IDs over time.

This Actor returns source records; it does not send alerts or calculate changes itself. Use an Apify schedule plus your own database, webhook, Make, Zapier, or n8n workflow for monitoring.

Why use this Actor?

• Discover hundreds of public event IDs from a city page without scrolling a browser.
• Extract both discovery and detail data in one run.
• Filter by free text, public Fever category, and an intersecting date range.
• Preserve stable IDs for deduplication and snapshot comparison.
• Include public price and default-session availability context alongside venue and schedule data.
• Stop at the requested result limit.
• Charge only records that pass filters.
• Fail clearly when Fever returns an invalid, blocked, or unsupported page instead of silently saving empty objects.

What Fever event fields are extracted?

Field	Meaning
eventId	Stable numeric Fever event ID
title	Public event or experience title
url, slug	Canonical event URL and public slug
city, cityCode, countryCode	Fever location identifiers
categories	Public category labels
startDate, endDate	First and last active public session dates
venue	Venue ID, name, address, latitude, and longitude
price, currency, priceType	Displayed minimum/default price context
availability	Default-session availability, count, ID, and label when public
rating	Public average, count, and visibility flag
imageUrl	Primary public image URL
description	Public event summary
sourceUrl, scrapedAt	Fetched detail URL and extraction timestamp

Some fields are null when Fever does not publish them for an event. A hidden rating is preserved as context; the Actor does not invent a score. Availability is a public snapshot, not a reservation or guarantee.

How to scrape Fever events

1. Click Try for free in Apify Console.
2. Add one or more public Fever city, category, search, or event URLs.
3. Optionally set search, category, dateFrom, or dateTo.
4. Set maxItems to the number of matching records you need.
5. Start the Actor and open the Fever events dataset view.
6. Export JSON, CSV, Excel, XML, or RSS, or connect the dataset to your workflow.

A useful first run is:

{
  "startUrls": [{ "url": "https://feverup.com/en/new-york" }],
  "maxItems": 10
}

Input parameters

startUrls

An array of 1–20 public feverup.com URLs. Supported inputs include city pages, category/search pages that expose public city event state, and /m/{eventId} detail pages. The default is the New York city page. URLs on other hostnames are rejected.

search

Optional case-insensitive text filter. It searches the title, event summary, city, venue name/address, and category labels. For example, Candlelight keeps Candlelight events discovered from the supplied city page.

category

Optional case-insensitive partial match against Fever's public category labels. Examples include Concerts and Sports. Category names differ by city and event.

dateFrom and dateTo

Optional ISO 8601 dates or date-times. An event is kept when its published active date range intersects the requested range. dateFrom must not be after dateTo.

maxItems

Maximum matching records to save, from 1 to 1,000. The default is 50. Filtering may require fetching more detail pages than the number ultimately saved.

Real output example

This shortened record came from the public Fever event URL https://feverup.com/m/555767:

{
  "eventId": 555767,
  "title": "LIV Golf New York 2026 - Grounds",
  "url": "https://feverup.com/m/555767/grounds-new-york-liv-golf",
  "city": "bedminster-nj-us",
  "countryCode": "US",
  "categories": ["Fun Sports", "Mini Golf", "Sports", "Sports & Activities"],
  "startDate": "2026-08-06T13:15:00-04:00",
  "endDate": "2026-08-09T11:05:00-04:00",
  "venue": {
    "name": "Trump National Golf Club Bedminster",
    "address": "900 Lamington Rd, Bedminster, 07921",
    "latitude": 40.65375110000001,
    "longitude": -74.6969661
  },
  "price": 28.14,
  "currency": "USD",
  "priceType": "from",
  "availability": {
    "hasAvailableTickets": true,
    "availableTickets": 9
  },
  "imageUrl": "https://applications-media.feverup.com/image/upload/..."
}

Values can change between runs as Fever updates event pages.

How much does it cost to scrape Fever events?

Pricing uses one start charge per run and one item charge for each matching event saved. The current BRONZE rates are $0.001 per run and $0.0008 per event. Higher subscription tiers receive lower per-event rates, from $0.00092 on FREE through $0.000224 on DIAMOND, as shown in Apify Console.

At BRONZE rates:

Saved events	Example price
1	0.0018 USD
10	0.009 USD
100	0.081 USD
1,000	0.801 USD

These examples describe Actor charges, not third-party integration or storage costs. Filters can reduce saved-item charges because rejected and duplicate records are not charged as items. Always check the live pricing panel for your subscription tier before a large run.

Common workflows

Build a city event feed

Schedule a city URL daily, store results keyed by eventId, and publish current titles, dates, venues, images, and URLs to a local guide.

Monitor new or changed events

Save each scheduled dataset to your warehouse. Compare eventId, startDate, endDate, price, and availability with the previous snapshot. Trigger your own notification only for changes you care about.

Enrich known event URLs

Supply /m/ URLs from an existing list. The direct-detail route avoids city discovery and returns normalized venue, schedule, category, price, rating, and image context.

Export to a spreadsheet or data pipeline

Download the default dataset as CSV or Excel, or use the dataset API from Airbyte, Make, Zapier, n8n, Google Sheets, or your own ETL code.

API usage with cURL

Replace APIFY_TOKEN with your Apify API token:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fever-events-discovery-scraper/runs?token=APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://feverup.com/en/new-york"}],"search":"Candlelight","maxItems":3}'

Fetch dataset items using the defaultDatasetId returned by the run API.

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/fever-events-discovery-scraper').call({
  startUrls: [{ url: 'https://feverup.com/en/new-york' }],
  category: 'Concerts',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fever-events-discovery-scraper').call(run_input={
    'startUrls': [{'url': 'https://feverup.com/m/555767'}],
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use Fever Events Scraper with MCP

Claude Code

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fever-events-discovery-scraper"

Claude Desktop, Cursor, and VS Code

Add this MCP JSON configuration in the client-specific MCP settings:

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

Example prompts:

• “Run Fever Events Scraper for New York and return three current events.”
• “Extract this Fever event URL and summarize its venue, dates, price, and availability.”
• “Find five New York Candlelight events and return stable IDs and dates.”

Reliability, limits, and retries

Fever's public page structure can change. The Actor validates the embedded state and fails loudly if the expected data surface disappears. Transient network errors, HTTP 429 responses, and server errors receive up to three bounded attempts with backoff. Stable invalid URLs and 4xx responses are not retried blindly.

Detail requests run with conservative concurrency. A city page may expose hundreds of candidates, so narrow filters can take longer than an unfiltered small run. The Actor currently uses direct HTTP and does not expose an automatic residential proxy fallback.

The returned price and availability describe the public default or displayed session at scrape time. They do not represent every ticket type, checkout fee, personalized offer, or guaranteed inventory.

Responsible use and legality

This Actor extracts publicly visible marketplace data. You are responsible for checking Fever's terms, robots guidance, applicable database rights, copyright rules, privacy laws, and the requirements of your use case.

Do not use the Actor to access accounts, favorites, checkout, payment flows, or personalized inventory. Do not republish protected descriptions or images unless you have permission. Use reasonable schedules and maxItems values, and avoid unnecessary repeated requests.

Troubleshooting

Why did my run return zero records?

Your search, category, or date range may not match any discovered event. First run the same URL with only a small maxItems, then inspect current category and date values before adding filters.

Why was my URL rejected?

Only public feverup.com HTTP/HTTPS URLs are supported. Check for a copied redirect, tracking domain, typo, or non-Fever hostname.

Why is an event field null?

Fever does not publish every rating, price, date, or availability value for every event. Null values preserve that uncertainty rather than inventing data.

Why does a filtered city run take longer?

Filters are evaluated on detail records. The Actor may need to fetch many event pages before it finds the requested number of matches.

Frequently asked questions

Does this Actor buy tickets or check out?

No. It only reads public discovery and event-detail pages.

Does it scrape Feverup Candlelight events?

Yes. Use a supported city page with search: "Candlelight", or supply known Candlelight event URLs.

Does it scrape Feverup careers or jobs?

No. Careers are outside this Actor's event-discovery scope.

Can I monitor changes automatically?

Schedule runs in Apify and compare datasets by eventId in your database or automation tool. The Actor provides snapshots; your downstream workflow decides what counts as a change.

Are all ticket types included?

No. The output contains public displayed/default-session price and availability context, not a checkout inventory export.

Related Automation Lab actors

• Luma Events Discovery Scraper for public Luma event feeds.
• StubHub Events Discovery Scraper for StubHub event discovery.
• DICE Events Scraper for DICE event catalogs.

Choose the source-specific Actor that matches the marketplace you need. Run separate Actors and join records downstream when you need multi-source event coverage.