# Fever Events Scraper (`automation-lab/fever-events-discovery-scraper`) Actor

Extract public Fever events by city, category, date, or URL for event aggregation and monitoring.

- **URL**: https://apify.com/automation-lab/fever-events-discovery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 86.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 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:

```json
{
  "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`:

```json
{
  "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:

```bash
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

```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

```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

```bash
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:

```json
{
  "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](https://apify.com/automation-lab/luma-events-discovery-scraper) for public Luma event feeds.
- [StubHub Events Discovery Scraper](https://apify.com/automation-lab/stubhub-events-discovery-scraper) for StubHub event discovery.
- [DICE Events Scraper](https://apify.com/automation-lab/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.

# Actor input Schema

## `startUrls` (type: `array`):

One or more public feverup.com city, category, search, or /m/ event URLs. City pages discover all event IDs; event URLs extract one event.

## `search` (type: `string`):

Keep events whose title, description, venue, city, or categories contain this text, for example Candlelight.

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

Keep events whose public Fever category contains this text, for example Concerts or Sports.

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

Keep events ending on or after this ISO 8601 date or date-time.

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

Keep events starting on or before this ISO 8601 date or date-time.

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

Maximum number of matching event records saved to the dataset.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://feverup.com/en/new-york"
    }
  ],
  "dateFrom": "2026-08-01",
  "dateTo": "2026-08-31",
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing all matching public Fever event records.

# 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 = {
    "startUrls": [
        {
            "url": "https://feverup.com/en/new-york"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fever-events-discovery-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 = {
    "startUrls": [{ "url": "https://feverup.com/en/new-york" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fever-events-discovery-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://feverup.com/en/new-york"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/fever-events-discovery-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fever-events-discovery-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YuxJ09YVODo6NU4q4/builds/UCTccmQf7X0c21ZZn/openapi.json