# Google Events Finder: Concerts, Shows & Venues (`xyrelith-data/google-events-scraper`) Actor

Search Google's Events results by query, place, country, language and date window. Export one row per event with venue, address, ISO dates, timezone, description, image, ticket and info links, prices, and venue rating.

- **URL**: https://apify.com/xyrelith-data/google-events-scraper.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Automation, Travel, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Events Finder: Concerts, Shows & Venues

Find what is happening in a city and export a clean event calendar from Google's Events results — one row per event, with the venue, full address, start and end times in local time and UTC, description, image, every ticket and information provider with its real URL and price, and the venue's rating and category.

The actor searches Google Events for your queries and places, fans each query out across the date windows you choose (today, tomorrow, this weekend, this week, next week, this month, next month), and de-duplicates the same event across all of them. No cookies, logins, API keys or proxy setup are required.

### What it does

- **Search by intent and place.** `concerts in new york`, `events in chicago`, `concerts in london` — any event-shaped query Google answers with its Events block.
- **Scan several date windows in one run.** Each selected window is a separate Google search; the same event found in two windows is returned once.
- **Open every event's detail panel.** That is where the full address, description, ticket providers, prices, venue rating and the event image live.
- **Resolve ticket links.** Google wraps provider links; the actor follows the redirect and stores the provider's real ticket URL, not a Google tracking link.
- **Parse dates and prices.** Locale-aware start/end dates, timezone, UTC timestamps, displayed price text, minimum price and currency where Google publishes one.
- **Stay resilient.** Requests are paced. If Google blocks a view, the actor retries it through a bounded ladder: a fresh direct context, a headed browser, an Apify AUTO proxy exit, then Google's Translate mirror. If every access route is blocked, a labelled snapshot of the last successful scan of the same view is served instead of returning nothing.

### Fields

| Field | Description |
| --- | --- |
| `eventId` | Google's event entity id (`/g/...`) |
| `title` | Event title |
| `startDate`, `startTime`, `startDateTime` | Start date and time (ISO; offset when the timezone is known) |
| `endDate`, `endTime`, `endDateTime` | End date and time when Google publishes a range |
| `timezone` | IANA timezone from Google's calendar link |
| `isAllDay` | `true` when Google gives an all-day or multi-day range (no clock time) |
| `startTimeUtc`, `endTimeUtc` | UTC timestamps |
| `dateText` | Date as Google shows it |
| `venueName`, `venueType` | Venue and its category (Live Music, Concert hall, Cafe, …) |
| `venueRating`, `venueReviewCount`, `venueDescription` | Venue rating details when shown |
| `address`, `streetAddress`, `city`, `region`, `postalCode`, `country` | Full address and its parsed parts |
| `description` | Event description from the detail panel |
| `imageUrl` | Event image (public Google thumbnail URL; card image rehosted when needed) |
| `priceText`, `priceMin`, `priceMax`, `priceCurrency`, `isFree` | Displayed price and parsed values when available |
| `ticketLinks` | Every ticket/info provider: `{provider, url, linkType, priceText, priceMin, priceCurrency, officialSeller}` |
| `ticketProvider`, `ticketUrl`, `officialTicketUrl` | Primary ticket provider and URLs |
| `infoProvider`, `infoUrl` | First information-only provider (venue site, Bandsintown, …) |
| `sourceUrl`, `sourceDomain`, `websiteUrl`, `mapsUrl`, `calendarUrl` | Event source and useful links |
| `query`, `searchQuery`, `datePreset`, `position` | Provenance of the row |
| `countryCode`, `language`, `scrapedAt`, `recordType` | Search market and timestamp |
| `retrievalMode` | How the row was obtained: `direct`, `proxy`, `mirror` or `cache` |
| `cacheSavedAt` | When the labelled cache snapshot used for a `cache` row was captured |

Every field is omit-empty: a value Google does not publish is absent, never `null`, `""`, or a placeholder.

### Input

| Input | Required | Description |
| --- | --- | --- |
| `searchQueries` | yes | Event searches, for example `concerts in new york`. You can also paste a `google.com/search?q=...` URL. Each plain query runs once per selected date window. |
| `location` | no | A city, region or country added as `in <location>` to every plain query. Leave empty when the place is already in the query. |
| `datePresets` | no | Multi-select: `any`, `today`, `tomorrow`, `this_weekend`, `this_week`, `next_week`, `this_month`, `next_month`. Default `any`. |
| `gl` | no | Google country market. Default `us`. |
| `hl` | no | Google interface language. Default `en`. |
| `includeDetails` | no | Open each event's detail panel for address, description, providers, prices and venue details. Default `true`. Turn off for a faster list. |
| `maxItems` | no | Stop after this many events. Default `100`, `3` in the saved example. |

Defaults:

| Input | Default |
| --- | --- |
| `searchQueries` | – (required) |
| `location` | – |
| `datePresets` | `["any"]` |
| `gl` | `us` |
| `hl` | `en` |
| `includeDetails` | `true` |
| `maxItems` | `100` |

The saved example is intentionally small: one query, one date window, three events. It is the cheapest run that still returns output.

### Output example

```json
{
  "eventId": "/g/11nw0yknwx",
  "title": "FunikiJam WORLD MUSIC FAIR",
  "startDate": "2026-11-21",
  "startTime": "11:00",
  "startDateTime": "2026-11-21T11:00:00-05:00",
  "endDate": "2026-11-21",
  "endTime": "12:00",
  "timezone": "America/New_York",
  "startTimeUtc": "2026-11-21T16:00:00Z",
  "dateText": "Nov 21, 2026, 11:00 AM",
  "venueName": "Actors Temple Theater Association",
  "venueType": "Live Music",
  "venueRating": 4.8,
  "venueReviewCount": 8,
  "address": "Actors Temple Theater Association, 339 W 47th St, New York, NY 10036",
  "streetAddress": "339 W 47th St",
  "city": "New York",
  "region": "NY",
  "postalCode": "10036",
  "country": "United States",
  "description": "Next up: Nov 21 Friendsgiving Edition! Interactive Off-Broadway family concert celebrating friendship, gratitude and fun.",
  "imageUrl": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9Gc...",
  "priceText": "From $23",
  "priceMin": 23,
  "priceCurrency": "USD",
  "ticketProvider": "Eventbrite",
  "ticketUrl": "https://www.eventbrite.com/e/2000964790553",
  "officialTicketUrl": "https://www.eventbrite.com/e/2000964790553",
  "ticketLinks": [
    {"provider": "Eventbrite", "url": "https://www.eventbrite.com/e/2000964790553", "linkType": "tickets", "priceText": "From $23", "priceMin": 23, "priceCurrency": "USD", "officialSeller": true},
    {"provider": "VenuNite", "url": "https://venunite.example/event", "linkType": "info"}
  ],
  "infoProvider": "VenuNite",
  "infoUrl": "https://venunite.example/event",
  "sourceUrl": "https://ongoing.in/new-york/venue/tank/new-york-new-music-festival",
  "sourceDomain": "ongoing.in",
  "websiteUrl": "http://www.actortempletheatre.org/",
  "mapsUrl": "https://maps.google.com/maps?...",
  "calendarUrl": "https://calendar.google.com/calendar/render?...",
  "query": "concerts in new york",
  "datePreset": "any",
  "position": 1,
  "countryCode": "us",
  "language": "en",
  "recordType": "googleEvent",
  "scrapedAt": "2026-11-15T12:00:00Z"
}
```

### How coverage works

Google shows about ten event cards per search view and no longer offers a second page. The actor therefore multiplies coverage in the only way Google supports: several queries and several date windows. A run with three queries and four date windows can return up to ~120 unique events before de-duplication. Add category queries (`concerts`, `comedy`, `theater`, `festivals`, `events`) or different neighbourhoods to widen a city calendar.

Selected date windows are applied to the parsed event dates: an event outside the window is excluded, while an ongoing multi-day event whose range overlaps the window is kept. Events that have already ended are skipped, including one-day events from earlier in the current weekend; the comparison uses the venue's own timezone, not the machine clock. `Any date` returns Google's full upcoming list without a window filter.

### Limitations

- **Event-shaped queries only.** Google renders its Events block for queries with event intent and a place (`concerts in new york`, `events in chicago`, `concerts in london`). Some topic-only queries (`comedy in chicago`, `tech meetups berlin`) do not render the block at all; the actor returns no rows for them rather than inventing data.
- **About 10 events per view, no pagination.** More rows come from more queries and date windows.
- **No online-only filter.** Google retired its virtual-event filter and online-worded searches no longer render the Events block. Event type and organizer are not published on event cards or detail panels either.
- **Prices are Google's display text.** `priceMin`/`priceCurrency` are best-effort parses of labels such as `From $23`, `Free` or `PKR 10,631`; inventory and final checkout prices are not available.
- **Multi-day end dates** follow the end value Google puts in its calendar link. All-day and multi-day ranges set `isAllDay` and omit clock times.
- **Date windows are exact for the parsed dates.** Google's own labels can differ by a timezone at the day boundary; the actor keeps an ongoing range if it overlaps the selected window.
- **Heavy runs are paced.** Google rate-limits rapid page loads. The actor waits between requests and rotates access only as needed: a fresh direct context, a headed browser, an Apify AUTO proxy exit, then the Translate mirror. No input or setup is needed.
- **Labelled cache fallback.** After a successful scan, the events for that query, market, language and date window are saved for seven days. If Google blocks every live route later, those rows are returned with `retrievalMode: "cache"` and `cacheSavedAt` so consumers can tell them apart. A cache row is never presented as a fresh live row.
- **Mirror rows.** If live access succeeds only through Google's Translate mirror, rows carry `retrievalMode: "mirror"`. Provider names and labels may be translated by that mirror; URLs are unwrapped back to the provider's real ticket page where possible.
- **Germany shows no Events block.** German-market searches (`gl: "de"`) currently return no event cards for event queries, in German or English. The actor returns zero rows rather than inventing events.
- **Today and tomorrow labels.** Google sometimes writes the date as `Today`, `Tomorrow` or a local-language equivalent; these are resolved against the venue market's timezone.
- **Images are Google's public thumbnails.** They are real event images, not generated placeholders.

### Data source

The actor reads the public Google Events results page and the event detail panel it opens. It does not sign in, buy tickets, or call any Google API that needs a key. Dates, prices and ticket links are shown as Google publishes them; verify important details with the organizer before publishing or purchasing.

### Integrations

Use the dataset directly, or connect the actor to schedules, webhooks, Google Sheets, Slack, n8n, Make, Zapier or any HTTP client through the Apify API. One scheduled run per city and category keeps an event calendar current.

### FAQ

**Why did a query return zero events?**
Google did not render its Events block for that query shape in that market. Add the word `events` or `concerts` and a place, for example `events in berlin` or `concerts in chicago`.

**Why are there only about ten events per query?**
That is Google's current Events block size. Use multiple queries and date windows; the actor de-duplicates the overlap.

**Do I need a proxy or cookies?**
No. The actor handles access itself and picks the cheapest route that works.

**What does `retrievalMode` mean?**
`direct` is Google's live page from the container. `proxy` and `mirror` are live fallbacks through an Apify AUTO exit and Google Translate. `cache` is the labelled snapshot described above, only used when every live route is blocked.

**Can I scrape a whole city's calendar?**
Use several category queries per city and select the date windows you care about. Adding neighbourhoods or venues as additional queries widens coverage further.

**Why is `priceText` missing on some events?**
Google does not publish a price for every event or provider. The field is omitted rather than guessed.

**Are ticket links direct?**
Yes. Google's redirect wrapper is followed and the provider's real URL is stored.

# Actor input Schema

## `searchQueries` (type: `array`):

What to find. Use event-shaped queries with a place, for example: concerts in new york, events in chicago, concerts in london next week. You can also paste a google.com/search?q=... URL. Each plain query runs once per selected date window.

## `location` (type: `string`):

Optional city, region or country added as 'in <location>' to every plain query. Leave empty when the place is already in the query.

## `datePresets` (type: `array`):

Google event date windows to collect. Each selected window is a separate search, and events found in several windows are returned once. Choose Any date for the broad upcoming list.

## `gl` (type: `string`):

Country market for the search (Google's gl parameter). It also sets the browser locale and the likely display currency.

## `hl` (type: `string`):

Language Google uses for result labels (Google's hl parameter).

## `includeDetails` (type: `boolean`):

Fetch the full event panel: address, description, ticket and info links with provider names, prices, venue rating and the event image. Turn off for a faster, lighter list with title, date, venue and city only.

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

Stop after this many events across all queries and date windows. Google returns about 10 events per search view.

## Actor input object example

```json
{
  "searchQueries": [
    "concerts in new york"
  ],
  "datePresets": [
    "any"
  ],
  "gl": "us",
  "hl": "en",
  "includeDetails": true,
  "maxItems": 3
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset containing every scraped Google event.

# 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 = {
    "searchQueries": [
        "concerts in new york"
    ],
    "datePresets": [
        "any"
    ],
    "gl": "us",
    "hl": "en",
    "includeDetails": true,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/google-events-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 = {
    "searchQueries": ["concerts in new york"],
    "datePresets": ["any"],
    "gl": "us",
    "hl": "en",
    "includeDetails": True,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/google-events-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 '{
  "searchQueries": [
    "concerts in new york"
  ],
  "datePresets": [
    "any"
  ],
  "gl": "us",
  "hl": "en",
  "includeDetails": true,
  "maxItems": 3
}' |
apify call xyrelith-data/google-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/google-events-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/qKcTUVOOZPyPQepUa/builds/xfa6gbDVCPY02dbRS/openapi.json
