Google Events | Scrape Google Events for AI Agents

🎭 Google Events Scraper | API for Claude, ChatGPT & Cursor (MCP)

Scrape Google events with one API call, concerts, conferences, festivals, sports, and theater. Built as a drop-in Google Events API for Claude, ChatGPT, Cursor, and other MCP-ready AI agents, and as a standard scraper for developers.

Pass any event search query and get structured JSON back: event titles, dates, start times, venues and addresses, ticket links and prices, with an optional details pass for descriptions and venue details. Switch to Sport Event Mode for a club or league's upcoming fixtures. Filter by date, from today through next month. Pay per event returned, no subscriptions.

📢 November 2026 update. Google's dedicated event listing surface is back, and this Actor reads it first again: ticket links, prices and venue links are in the output once more, with the results-page block kept as a fallback. Separately, Google removed sport from its event listings on every surface in early November, so sports-worded searches now return nothing anywhere. That is what the new Sport Event Mode is for. See What changed in 2026 for the full history.

---

🤖 Use with Claude, ChatGPT, Cursor & other AI agents (MCP)

This Actor is a first-class tool on the Apify MCP Server. Any MCP-compatible AI agent, Claude (Desktop, Web, Code), ChatGPT (via custom GPT or MCP bridge), Cursor, VS Code, Cline, Windsurf, Kilo Code, Opencode, Glama, can discover and call this Actor in natural language.

What an AI agent does with this:

User: "What family-friendly events are happening in Brooklyn this month?"

Agent → calls search-actors("google events") on the Apify MCP server → picks this Actor → calls it with {"q": "family events brooklyn", "location": "Brooklyn, NY", "advanced": "date:month"} → returns structured event JSON → summarizes for the user.

Quick setup: Claude Desktop

Add this to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN"
      }
    }
  }
}

Restart Claude Desktop. Then ask Claude something like "Search Google Events for tech meetups in San Francisco next week.", Claude will discover this Actor, ask permission to call it, and return structured results.

Quick setup: Cursor / VS Code / Cline / Windsurf

These editors support dynamic tool discovery, which means after the first call this Actor is registered as a named tool for the rest of the session, subsequent prompts skip the discovery step entirely.

Point your MCP client at:

https://mcp.apify.com

…with header Authorization: Bearer YOUR_APIFY_API_TOKEN. Full setup instructions: Apify MCP integration docs.

Quick setup: ChatGPT (and other static MCP clients)

ChatGPT, Claude Desktop (without dynamic discovery), Gemini CLI, and Amazon Q connect through the same https://mcp.apify.com endpoint and call this Actor via the generic call-actor tool, same result, just no session-level tool registration.

Use cases for AI agents

• 🤖 Event-discovery assistants: "Find me what's happening this weekend near {city}."
• 📅 Calendar copilots: Auto-suggest events that match the user's interests and free slots.
• 🎟️ Event-monitoring agents: "Which concerts are at {venue} this month?"
• 🏢 Sales / lead-gen agents: Surface industry conferences and trade shows where prospects gather.
• 📊 Research agents: Aggregate event data across cities for market analysis or trend reports.

---

💸 Pay per run with crypto (x402)

The Google Events Actor supports agentic payments via the x402 protocol. AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed: point your agent at the Apify MCP server and it can discover, pay for, and run this Actor autonomously. Read the Apify x402 announcement for details.

💡 What this Actor does

A Google Events Scraper that takes a search query and pulls structured event data straight from Google's search results: titles, event types, dates, start times, and venue addresses, returned as clean JSON.

Whether you're powering an AI agent through MCP, building an event-discovery app, monitoring competitor events, or aggregating concert and conference data into a dataset, this scraper handles the platform-side complexity so you don't have to.

✅ SEO benefit: Structured Google Events data lets businesses optimize event listing pages, monitor competition, and create data-rich content that boosts organic visibility.

---

📦 What data you get

Field	Description
🎭 Event title	Display title of the event
🏷️ Event type	Short category or venue label, e.g. "Live music", "Festival", "TV history exhibition"
📅 Date & time	Start date (Aug 14), start time (2:30 PM), and a combined when label
📍 Location	Address lines, typically venue name followed by city, plus a venue object with the venue's name and Google link
🎟️ Tickets	Ticket and info links (ticket_info) with the seller's name; the primary one is also exposed as link / source
💵 Price	Price label ($36) and its numeric form, on the listings that publish one
🗺️ Map link	Google Maps link for the venue when published
📝 Description & venue details	With include_details: the full event description and the venue's type and description
🏟️ Fixtures (Sport Event Mode)	Match title, competition, kick-off date and time, venue, teams, status and scores
📊 Search metadata	Event count, which Google surface answered, how many lookups were made, and the search parameters used

Still not published by Google: venue ratings and review counts on event listings (pair the venue name with the Google Maps Places API for those). description and venue are always present, as an empty string and an empty object when nothing is published, so integrations built against earlier versions keep parsing.

---

⚙️ Key features

✨ Every field Google publishes: titles, dates, start times, venues and addresses, ticket links, prices, map links, and with include_details the full description and venue details.

🏟️ Sport Event Mode: Google no longer lists sport under events, so mode: "sport_events" reads its fixtures block instead. Pass a club, league or competition name and get the upcoming games with date, kick-off time, venue and teams, in the same output shape.

🔁 Fallback chain, never billed: the dedicated listing surface first, the results-page block second, a bare-query retry last. At most three lookups per run; you pay per event returned, never per lookup.

🔍 Date filtering: today, tomorrow, this week, this weekend, next week, this month, or next month. Applied by rewriting the search query, and verified live to return in-window results. The one filter Google no longer supports at all is rejected before any charge, rather than quietly returning unfiltered results.

🌍 Localization: Country (gl) and language (hl) parameters localize results to any of 240+ countries and 200+ languages.

📦 One batch per run: Google returns up to 10 event listings per query. You are charged once per run regardless, so cost is predictable.

💰 Transparent per-event pricing: $0.0125 setup + $0.00165 per event returned, at most $0.029 per run; the optional details pass adds $0.015 per detailed event. No subscriptions, no minimums.

🛡️ Production-grade reliability: 99.9% success rate on live traffic, comprehensive error handling, schema-validated output.

🤖 MCP-ready: First-class tool on the Apify MCP Server for Claude, ChatGPT, Cursor, and any other MCP-compatible agent.

---

🚀 Getting Started

Pulling your first batch of Google Events data takes about a minute:

1. Click Try for free at the top of this page (or open the Actor in the Apify Console).
2. Enter a search query in q, for example concerts in New York or tech conferences this week. That is the only required field.
3. Optionally set location, gl, hl, the advanced filters, and max_pages, then click Start.
4. Read the results in the Output tab, or export them as JSON, CSV, or Excel.

Prefer code or an AI agent? Call the Actor through the Apify API with the apify-client package, or add it as a tool to Claude, ChatGPT, or Cursor through the Apify MCP server. Both paths are covered in the sections below.

---

📖 Usage examples

Example 1: Basic search (events in New York)

{
  "q": "events in New York"
}

Example 2: Search with location and localization

{
  "q": "concerts in Austin",
  "location": "Austin, Texas, United States",
  "gl": "us",
  "hl": "en"
}

💡 Put the city in q plainly and the precise place in location. A state in the query itself reliably returns nothing: "Festivals in Portland, OR" returns 0 results while "Festivals in Portland" with location: "Portland, Oregon, United States" returns a full batch.

Example 3: Today's events

{
  "q": "comedy shows in Los Angeles",
  "location": "Los Angeles, California, United States",
  "advanced": "date:today"
}

Example 4: Next month, filter passed as an array

{
  "q": "music festivals in San Diego",
  "location": "San Diego, California, United States",
  "gl": "us",
  "hl": "en",
  "advanced": ["date:next_month"]
}

Example 5: Every parameter

{
  "q": "theater shows in Chicago",
  "location": "Chicago, Illinois, United States",
  "gl": "us",
  "hl": "en",
  "advanced": "date:month",
  "max_pages": 1
}

Example 6: Covering a whole city

Google returns up to 10 listings per query, so cover a market by running several category queries rather than by asking for more pages:

{ "q": "concerts in Nashville",   "location": "Nashville, Tennessee, United States" }
{ "q": "festivals in Nashville",  "location": "Nashville, Tennessee, United States" }
{ "q": "theater in Nashville",    "location": "Nashville, Tennessee, United States" }
{ "q": "comedy in Nashville",      "location": "Nashville, Tennessee, United States" }

For the city's sport, use Sport Event Mode per club: { "mode": "sport_events", "q": "Nashville Predators" }.

💡 For a neighborhood, query the parent city and pass the neighborhood as location. "events in Summerlin" returns far less than "events in Las Vegas" with location: "Summerlin".

Example 7: Sport Event Mode, one club

{
  "mode": "sport_events",
  "q": "Chelsea",
  "gl": "uk",
  "hl": "en"
}

Returns Chelsea's next fixtures (typically five or six) with competition, date, kick-off time, venue and both teams. "Premier League" returns the next round across the league; "Harlequins", "Celtic", "NBA" and "England cricket" all work the same way. A city name does not: Google renders fixtures per club or competition, not per place, so cover London football with one run per London club.

Example 8: Descriptions and venue details

{
  "q": "concerts in Austin",
  "location": "Austin, Texas, United States",
  "include_details": true
}

Adds the full event description and the venue's type and description to each listing. One extra lookup per event, billed at $0.015 per detailed event.

---

🔍 Input parameters

Parameter	Type	Required	Default	Description
mode	string	❌	events	events for event listings in a place; sport_events for the fixtures of the club, league or competition named in q. See Why Sport Event Mode exists.
q	string	✅ Yes	None	Search query (e.g. "concerts in New York", "tech conferences in Chicago"). Name the city plainly; put the state or precise place in location. In Sport Event Mode: a club, league or competition name ("Chelsea", "Premier League").
location	string	❌	None	Geographic location to bias results toward (e.g., "Austin, Texas, United States").
gl	string	❌	None	Country code (ISO 3166-1 alpha-2, lowercase). Applies to Sport Event Mode and the results-page fallback; the primary listing surface answers in English with US formatting regardless.
hl	string	❌	None	Language code (ISO 639-1, lowercase). Same scope as gl. A non-English value runs the localized results-page lookup first.
include_details	boolean	❌	false	Events mode only. Fetch the description and venue details for each listing (one extra lookup per event, at most 10, billed per detailed event).
advanced	string or array	❌	None	Date filter: date:today, date:tomorrow, date:week, date:weekend, date:next_week, date:month, date:next_month. See the date-filters section below.
max_pages	integer	❌	1	Retained for compatibility. Event listings arrive in a single batch, so any value is treated as 1 and you are charged for one run.
output_file	string	❌	auto-generated	Optional JSON filename for local runs (ignored when run on the Apify platform).

---

🌍 Country codes (gl parameter)

The gl parameter accepts ISO 3166-1 alpha-2 country codes (lowercase). Most common:

Code	Country	Code	Country	Code	Country
us	United States	uk / gb	United Kingdom	ca	Canada
au	Australia	de	Germany	fr	France
it	Italy	es	Spain	nl	Netherlands
be	Belgium	at	Austria	ch	Switzerland
se	Sweden	no	Norway	dk	Denmark
fi	Finland	pl	Poland	cz	Czech Republic
ie	Ireland	pt	Portugal	gr	Greece
jp	Japan	kr	South Korea	cn	China
tw	Taiwan	hk	Hong Kong	sg	Singapore
my	Malaysia	th	Thailand	id	Indonesia
ph	Philippines	vn	Vietnam	in	India
nz	New Zealand	za	South Africa	br	Brazil
mx	Mexico	ar	Argentina	cl	Chile
co	Colombia	pe	Peru	ve	Venezuela

240+ country codes are supported. Pick the closest from the dropdown in the input schema.

---

🌐 Language codes (hl parameter)

The hl parameter accepts ISO 639-1 language codes (lowercase). Most common:

Code	Language	Code	Language	Code	Language
en	English	es	Spanish	fr	French
de	German	it	Italian	pt	Portuguese
ru	Russian	ja	Japanese	ko	Korean
zh	Chinese	zh-cn	Chinese (Simplified)	zh-tw	Chinese (Traditional)
ar	Arabic	hi	Hindi	th	Thai
vi	Vietnamese	id	Indonesian	ms	Malay
tl	Filipino	nl	Dutch	pl	Polish
tr	Turkish	cs	Czech	sv	Swedish
da	Danish	fi	Finnish	no	Norwegian
hu	Hungarian	ro	Romanian	bg	Bulgarian

200+ language codes are supported. Pick the closest from the dropdown.

---

🎯 Date filters

The advanced parameter accepts the same date tokens the old events vertical used. Each one is applied by naming the date window in the search query, which works on every surface this Actor reads (re-verified on the listing surface in November 2026: date:tomorrow returned next-day labels only, date:week and date:weekend stayed in their windows). The same tokens work in Sport Event Mode.

Token	Meaning
date:today	Events today
date:tomorrow	Events tomorrow
date:week	Events this week
date:weekend	Events this weekend
date:next_week	Events next week (Google's weeks run Sunday to Saturday)
date:month	Events this month
date:next_month	Events next month

{ "advanced": "date:weekend" }
{ "advanced": ["date:next_month"] }

One date filter takes effect per run; if several are passed, the first is applied. If your query already names the window ("concerts in Austin today"), your text wins and nothing is appended.

An empty result inside a narrow window is honest, not broken: a small market can genuinely have nothing on for "today", and in that case the results fee is not charged.

A query that is only "events" plus a place, with no topic and no date, often no longer renders an events block at all. The console prefill, events in Austin, is that shape. When it happens, and you did not set a date filter, the actor retries once with "this week" added. A query that names a topic, such as concerts in Austin, is sent as you wrote it, and a date you asked for is never widened.

⚠️ The token for "this month" is date:month, not date:thismonth. An unrecognized token exits the run at start, before any charge, with a clear error.

The one filter that stayed retired

event_type:Virtual-Event is still rejected at run start. We measured it: queries shaped for virtual events return overwhelmingly in-person listings, so accepting the token would hand back misleading results. If you want online events, add "online" or "webinar" to the query text and treat the results as best-effort.

---

🏟️ Why Sport Event Mode exists

In early November 2026 Google stopped including sport in its event listings, on every surface it publishes them on and in every market we tested (London, Glasgow, New York, Austin). A search such as "sports events in London this week", "football OR rugby OR concerts in London" or "sports events in Austin" now returns no event listings at all, while "concerts in London this week" or "events in Austin this week" still return a full batch. There is no query wording that brings sport back into the listings; we tried about thirty.

Google does still publish sport, just not as events: it renders a fixtures block for a club, league or competition. Sport Event Mode reads that block.

• Set "mode": "sport_events" and put a club, league or competition name in q: "Chelsea", "Premier League", "Harlequins", "Celtic", "NBA", "England cricket".
• Each run returns the next games Google lists for that name, typically five or six, as event rows: title ("Chelsea vs Leeds"), tournament, date and time, address and venue_name when Google names the ground, teams (home first), and status plus scores for games already played.
• Billing is the same as any event: the setup fee plus one event_returned per game.
• A city or a generic phrase ("football in London") does not render the block. To cover a city, run one query per club based there.

In events mode, a sports-worded query now makes a single lookup and, when it comes back empty, stores one row with no events and a hint field that says all of this. It never substitutes generic city listings for the sport you asked about.

---

📊 Output format

In the Apify console the dataset opens on an Events table, one row per event with its title, type, when, venue, area, price and link; Sport fixtures shows one row per game in Sport Event Mode; the Search summary view shows one row per run. Exports (JSON, CSV, Excel) carry the full structure below.

One dataset item is pushed per run. Below is a real response from the listing surface, trimmed to one event:

{
  "search_parameters": {
    "q": "concerts in London",
    "location": "London, England, United Kingdom",
    "gl": "uk",
    "hl": "en",
    "advanced": "date:week",
    "max_pages": 1,
    "applied_hit_chips": ["date:week"],
    "mode": "events",
    "include_details": false
  },
  "search_metadata": {
    "total_results": 10,
    "events_count": 10,
    "hit_chips_count": 0,
    "filters_count": 0,
    "pages_processed": 1,
    "max_pages_set": 1,
    "pagination_limit_reached": false,
    "upstream_calls": 1,
    "details_fetched": 0,
    "listing_source": "events_listing"
  },
  "search_timestamp": "2026-11-12T09:30:00.123456",
  "page_number": 1,
  "mode": "events",
  "events": [
    {
      "title": "Candlelight: Ed Sheeran & Coldplay in London",
      "date": {
        "start_date": "Dec 5",
        "when": "Dec 5, 6:30 PM"
      },
      "when": "Dec 5, 6:30 PM",
      "time": "6:30 PM",
      "address": [
        "Central Hall Westminster",
        "London, United Kingdom"
      ],
      "venue_name": "Central Hall Westminster",
      "area": "London, United Kingdom",
      "venue": {
        "name": "Central Hall Westminster",
        "link": "https://www.google.com/search?q=Central+Hall+Westminster&ludocid=..."
      },
      "ticket_info": [
        { "source": "feverup.com", "link": "https://feverup.com/m/395155", "link_type": "tickets" }
      ],
      "link": "https://feverup.com/m/395155",
      "source": "feverup.com",
      "price": "$36",
      "extracted_price": 36,
      "map_link": "https://maps.google.com/?cid=...",
      "description": ""
    }
  ],
  "hit_chips": [],
  "filters": []
}

A Sport Event Mode row has the same envelope with "mode": "sport_events", "listing_source": "sports_results" and search_metadata.league, and each event looks like this:

{
  "title": "Chelsea vs Leeds",
  "type": "Premier League",
  "tournament": "Premier League",
  "date": { "start_date": "Sat 21 Nov", "when": "Sat 21 Nov, 16:00" },
  "when": "Sat 21 Nov, 16:00",
  "time": "16:00",
  "address": ["Stamford Bridge"],
  "venue_name": "Stamford Bridge",
  "venue": { "name": "Stamford Bridge" },
  "teams": [ { "name": "Chelsea" }, { "name": "Leeds" } ],
  "description": ""
}

Top-level fields

• search_parameters - The exact input that produced this result, plus mode, include_details and, when a retry or a shaped fixtures query produced the results, query_sent.
• search_metadata - Event count, listing_source (which Google surface answered), upstream_calls, details_fetched, and league in Sport Event Mode.
• search_timestamp - ISO 8601 timestamp when the search ran.
• page_number - Always 1.
• mode - events or sport_events.
• events - Array of event objects (see below).
• hint - Only on an empty row whose query shape cannot return anything on that surface (a sports-worded events query, a city name in Sport Event Mode). Says what to change.
• hit_chips - Always empty. Retained so the row shape is unchanged.
• filters - Always empty. Retained so the row shape is unchanged.

Event fields

• title - Event display title.
• type - Short category or venue label, e.g. "Live concert", "Festival".
• date.start_date - Short date label, e.g. "Aug 14".
• date.when - Start date combined with start time, e.g. "Aug 14, 2:30 PM".
• time - Start time on its own. Absent on all-day and multi-day listings.
• address - Array of address lines, usually venue name then city or neighborhood. venue_name and area repeat them as flat fields.
• venue - name and Google link for the venue; with include_details, also type and description. {} when Google publishes none.
• ticket_info - Ticket and info links with the seller's name and a link_type of tickets or more info.
• link / source - The primary link: the ticket link when there is one, otherwise the listing's own link when present.
• price / extracted_price - Price label and number, on the listings that publish one.
• map_link - Google Maps link for the venue when published.
• description - Full description with include_details; otherwise "".
• Sport Event Mode adds tournament, teams (home first, with score on finished games), status and scores.

---

📢 What changed in 2026

Google changed how it publishes events twice this year. The row shape never changed: date is an object with start_date and when, address is a list, description is a string and venue is an object, so integrations built against any version keep parsing.

August 2026. Google retired its dedicated events vertical (ibp=htl;events). The Actor moved to the events block on the main search results page: one batch of up to 10 listings, no second page, date filters applied by rewriting the query text, and no descriptions, ticket links or map previews.

November 2026. Two changes in the same week:

What	Status
Listing surface	Back, as Google's dedicated event listing surface. The Actor reads it first again, with the results-page block as fallback. Ticket links, prices, venue links and map links are in the output once more; include_details restores descriptions and venue details.
Sport	Removed from event listings on every surface. Sports-worded searches return nothing anywhere; the new Sport Event Mode reads Google's per-club and per-league fixtures block instead.
Bare city queries	"events in {city}" with no topic and no date stopped rendering on October 31. The Actor retries that one shape with "this week" appended.
Pagination	Still gone on every surface. max_pages is accepted but has no effect.
Language and country	The listing surface answers in English with US formatting. gl and hl still apply to the results-page fallback and to Sport Event Mode; a non-English hl runs the localized fallback first.

Covering more events. One query returns up to 10 listings, so cover a market with several category queries rather than by requesting more pages. See Example 6. For sport, run one Sport Event Mode query per club.

---

💸 Pricing

This Actor uses Apify's pay-per-event model:

Event	Price	When charged
Setup	$0.0125	Once per run, at start
Event returned	$0.00165	Per event listing or fixture stored, up to 10 per run
Event details	$0.015	Per event enriched by include_details (off by default)

A full 10-event search costs $0.029; with details, $0.179. Sport Event Mode bills exactly like events: setup plus one event per game. Higher subscription tiers pay less per event.

Lookups are never billed, only events: the fallback to the results page, the bare-query retry and a sports-worded query's single lookup cost you nothing beyond the setup fee. A query that returns no events pays only the setup fee, and a run that fails validation (an unknown mode, an unrecognized or retired filter token) exits before any charge at all. A pre-run funds check confirms you can afford the run before any work begins.

---

🎯 Use cases

• 🤖 AI agents (MCP): Plug into Claude, ChatGPT, Cursor and let the agent discover & call this tool natively.
• 📅 Event-discovery apps: Build event-aggregation platforms with up-to-date Google Events data.
• 📊 Market research: Analyze event trends, popularity, and venue saturation across cities.
• 🏢 Competitive analysis: Monitor which events competitors run and where.
• 🏟️ Venue programming trackers: See which venues in a metro are booking the most events.
• 📈 Lead generation: Identify trade shows and conferences where target customers will be.
• ✍️ Content creation: Generate event-round-up articles for local-events SEO content.
• 🌐 Virtual-event discovery: Add "virtual" or "online" to the query to surface remote events.
• 📡 Google Events tracking: Re-run saved searches on a schedule to track new listings, venue changes, and sold-out status across a city over time.

---

🔌 Integrations: Automate Google Events Tracking

A single search answers one question. The real value of this Google Events API comes from running it repeatedly, watching a city's calendar week over week, catching newly listed concerts and conferences, and feeding live event data into the tools you already use. Thanks to the native Apify platform integrations, you can wire this Actor into your stack in minutes, with no servers or cron jobs of your own.

Tasks + Schedules: register a recurring events run

The core pattern for Google Events tracking is one saved task per search, one schedule across all of them.

1. Create a task. A saved task is this Actor plus a saved input, so give each search you care about its own named task, for example "SF tech conferences" with q: "tech conferences", location: "San Francisco, CA", and advanced: "date:month". Click Create empty task on the Actor page, fill in the input, and save.
2. Attach a schedule. Open Schedules in the Apify Console, create a schedule with a standard cron expression, and add your tasks to it. Useful examples: 0 7 * * * (every morning at 7 AM), 0 */6 * * * (every 6 hours), 0 9 * * 1 (Mondays at 9 AM). One schedule can trigger many tasks, so a single "daily events check" can monitor every city and query you have saved.
3. Review the history. Each run appends a fresh batch of results, stamped with a search_timestamp, to the task's dataset, giving you an event history you can export as JSON, CSV, or Excel at any time.

See it working end to end in the featured task Find concerts and festivals in Austin this weekend.

n8n: build an event-alert workflow

This Actor also ships as a dedicated n8n community node, n8n-nodes-google-events-api (see the n8n integration section near the end of this README), so you do not need raw HTTP requests. In n8n: Settings, Community Nodes, install n8n-nodes-google-events-api, then use it in any workflow (it also works as an AI Agent tool).

A typical event-alert workflow looks like this:

1. Schedule Trigger: run every morning at 7 AM.
2. Google Events node: search your query, for example concerts in your city.
3. Filter node: keep only events matching your criteria (a date range, a venue, a keyword).
4. Slack or email node: send yourself the title, type, date, and venue when a new event appears.

Make and Zapier

Prefer Make or Zapier? Both have native Apify integrations, Apify on Make and Apify on Zapier, with "Run Actor" and "Get Dataset Items" actions. The same event-alert pattern applies: trigger on a schedule, run this Actor, filter on what matters, then notify or store the results.

Supabase: store an event history in your own database

Tracking events over time means storing them somewhere queryable. Supabase (hosted Postgres) is a good fit, and there are two easy paths:

• No code: in n8n, connect the Google Events node to the built-in Supabase node to insert a row per event after each scheduled run.
• A few lines of Python: run the Actor and bulk-insert the flat event rows into an events table.

from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("https://YOUR_PROJECT.supabase.co", "YOUR_SERVICE_ROLE_KEY")

run = apify.actor("johnvc/google-events-api---access-google-events-data").call(
    run_input={
        "q": "concerts",
        "location": "Austin, Texas, United States",
        "gl": "us",
        "hl": "en",
        "max_pages": 2,
    }
)

for page in apify.dataset(run["defaultDatasetId"]).iterate_items():
    rows = [
        {
            "title": event["title"],
            "event_when": event.get("date", {}).get("when"),
            "address": ", ".join(event.get("address", [])),
            "venue": event.get("venue", {}).get("name"),
            "link": event.get("link"),
            "searched_at": page["search_timestamp"],
        }
        for event in page.get("events", [])
    ]
    if rows:
        supabase.table("events").insert(rows).execute()

Run this on a schedule (or trigger it from a webhook, below) and you have a growing event database ready for dashboards, a city-events app, or trend analysis.

MCP and AI agents

Apify exposes this Actor through the Apify MCP server, so MCP-compatible AI assistants, Claude, Cursor, and others, can run live Google Events searches as a tool and answer questions like "what family-friendly events are on in Brooklyn this weekend?" with real data. That is what turns this into a Google Events AI agent rather than a one-off script. If you drive it from Claude Code (free trial), the same MCP endpoint applies. See the Use with Claude, ChatGPT, Cursor & other AI agents (MCP) section near the top for one-click client setup.

Webhooks: connect anything else

For custom setups, attach an Apify webhook to the ACTOR.RUN.SUCCEEDED event. Every time a scheduled run finishes, Apify POSTs the run details (including the dataset ID) to your endpoint, your server, an n8n or Make webhook trigger, or a serverless function, which can then fetch the results and do anything with them: update a Google Sheet, refresh a dashboard, or post the night's events to a channel.

---

🔗 Related Tools

Building an event-discovery or event-and-travel workflow? These related tools from the same collection pair well with this Google Events API:

• Google Maps Places API: enrich the venues that show up in your event data with full business details, ratings, phone numbers, and opening hours.
• Google Flights API: find and track flight prices for the cities where events are happening, so an "attend this conference" plan includes getting there.
• Google Hotels Search Scraper: pull hotel availability and pricing near an event venue to round out an event-and-travel dataset.

This Actor is actively maintained, rated 5 stars, documents every output field, and validates its JSON against a schema on every run.

---

🤖 Ask an AI assistant about this API

Open a ready-to-send prompt about the Google Events Actor in the AI of your choice:

• 💬 ChatGPT
• 🧠 Claude
• 🔍 Perplexity
• 🅒 Copilot

❓ FAQ

How do I get started?

Provide a q (search query). That is the only required parameter. Run the Actor and it returns structured JSON.

Is q required?

Yes. Everything else is optional.

Can I filter results by date?

Yes. Use advanced with date:today, date:tomorrow, date:week, date:weekend, date:next_week, date:month, or date:next_month. The filter is applied by rewriting the search query, and we verified live that it returns in-window results. See the date-filters section above.

How do I search for virtual events only?

Add "virtual" or "online" to your query, e.g. "q": "virtual conferences in Chicago". The event_type:Virtual-Event token was retired with Google's events vertical and is rejected at run start.

Can I use multiple filters at once?

The advanced parameter still accepts a comma-separated string or an array, but one date filter takes effect per run (the first listed). Combine it with words in the query for anything else.

How does pagination work?

It no longer applies. Google returns one batch of up to 10 event listings per query, so there is no second page to fetch. max_pages is still accepted so existing inputs keep running, but any value is treated as 1 and you are charged once. To cover more of a market, run several category queries instead.

Can I search in different countries and languages?

Yes, gl (country code) and hl (language code), 240+ countries and 200+ languages. They apply to Sport Event Mode and to the results-page fallback; the primary listing surface answers in English. Target any country's events through the query and location ("events in Paris" works).

What format does the scraper return?

Structured JSON. Each page of results is pushed as a separate dataset item. Results can be exported as JSON, CSV, Excel, or accessed via Apify's API.

Does this work with AI agents through MCP?

Yes, see the Use with Claude, ChatGPT, Cursor & other AI agents (MCP) section near the top. MCP-compatible clients can discover and call this Actor natively.

How do I use the location parameter?

Pass a human-readable location string: "Austin, Texas, United States", "London, England, United Kingdom", "New York, NY".

What if my search returns no results?

search_metadata.events_count is 0 and events is an empty array. The Actor still completes successfully, you are only charged the setup fee in that case. If the query shape itself cannot return anything on that surface, the row also carries a hint that says what to change.

Why does my sports query return nothing?

Because Google removed sport from its event listings in November 2026, on every surface. "sports events in London", "football OR rugby OR concerts in London" and "sports events in Austin" all return zero listings now, whatever the wording. Use Sport Event Mode instead: {"mode": "sport_events", "q": "Chelsea"}. See Why Sport Event Mode exists.

How do I get fixtures for a team or league?

Set mode to sport_events and put the club, league or competition name in q: "Chelsea", "Premier League", "Harlequins", "NBA". Each run returns the next games Google lists for that name with competition, date, kick-off time, venue and teams. A city name does not work there; run one query per club.

Do I get ticket links and prices?

Yes, on event listings from the listing surface: ticket_info holds every ticket and info link with its seller, the primary one is repeated as link / source, and price is present on the listings that publish one. Set include_details for the full description and the venue's type and description.

Do gl and hl still matter?

For Sport Event Mode and the results-page fallback, yes. The primary listing surface answers in English with US-formatted dates regardless of them. A non-English hl makes the Actor run the localized fallback first, so localized callers keep localized results.

Can I schedule this Google Events Scraper?

Yes, and this is where the Actor earns its keep. Any run can be automated on a schedule. Create a saved task with your query and filters, then attach a schedule from the Actor's Actions, then Schedule menu. Useful cron expressions: 0 7 * * * (daily at 7 AM), 0 */6 * * * (every six hours), 0 9 * * 1 (Mondays at 9 AM). One schedule can trigger many tasks at once, so a single "daily events check" can watch every city and query you have saved. See the Integrations section above for the full monitoring recipe.

Should I use an API or a web scraper for Google Events?

There is no official public Google Events API, so your options are an unofficial API endpoint or a web scraper. This Actor is both in one: call it like a clean API you run yourself, or use it as a no-code web scraper from the Apify Console, with no quotas or API keys to manage. Either way it reads the public event listings that appear in Google Search and returns the same structured event data.

Can I integrate this Google Events Scraper with other apps?

Yes. The Actor connects to almost any cloud service through Apify integrations: Make, Zapier, Slack, Google Drive, and more. For anything custom, attach a webhook on the ACTOR.RUN.SUCCEEDED event. See the Integrations section above for ready-to-use recipes.

Can I use Google Events data with the API?

Yes. The Apify API gives you programmatic access to run the Actor, schedule it, and fetch datasets, and the apify-client package is available for both Node.js and Python. Grab your endpoints from the Actor's API tab.

Can I use this Google Events API through an MCP server?

Yes. The Actor can be added as a tool to any MCP client (Claude, Cursor, and others) through the hosted Apify MCP server. Point your client at https://mcp.apify.com/?tools=actors,docs,johnvc/google-events-api---access-google-events-data. If you are driving it from Claude Code (free trial), the same endpoint applies. Full setup: Apify MCP docs.

How can I track other Google and events data sources?

Pair this Actor with complementary tools from the same collection. Use the Google Maps Places API to enrich event venues, the Google Flights API to track travel to those events, and the Google Hotels Search Scraper for nearby lodging. See the Related Tools section above for how they fit together.

What can an AI agent do with this Google Events API?

An AI agent that supports MCP can discover this Actor, call it with a natural-language request like "family-friendly events in Brooklyn this weekend", and get back structured JSON it can summarize, filter, or store. That is what makes it a practical building block for a Google Events AI assistant, a calendar copilot, or an event-discovery bot.

Can I use this for market research?

Yes. Aggregating events across cities and dates is a common market research use: track how many concerts, conferences, or festivals appear in a metro over time and which venues host the most. Run it on a schedule and store each run to build the history.

Is it legal to scrape Google Events?

Scraping publicly available data is generally permitted, though you are responsible for how you use the data you collect. Apify has a plain-English overview of the legality of web scraping. This Actor only reads public Google Events results.

How much does it cost?

$0.0125 setup + $0.00165 per event returned, so a full 10-event search costs $0.029 and an empty one only the setup fee. The optional details pass adds $0.015 per detailed event. Sport fixtures bill like events. No subscriptions, no minimums. See the Pricing section above.

---

📝 Technical notes

• Results are sorted by Google Events' default relevance ordering.
• The q parameter is required and must be non-empty.
• Unrecognized and retired filter tokens are both caught at run start, before any charges are applied; the Actor exits gracefully with an error naming the token and what to use instead.
• Each page is pushed as its own dataset item, so per-page billing matches actual deliverables exactly.
• All output is JSON-serialized and schema-validated before being pushed.
• max_pages is accepted but never fetches more than one batch, because Google returns event listings on a single page. You are charged for one run regardless of the value.
• location, gl, and hl are optional but recommended for sharper localization.
• At most three listing lookups per run (listing surface, results page, bare-query retry), plus at most one details lookup per event when include_details is on. Only events are billed.
• Venue ratings and review counts are not published on event listings. description and venue are present in every row, filled by the details pass or left empty, so existing integrations keep parsing.
• Sport Event Mode makes one lookup of Google's fixtures block and returns each game as an event row; finished games keep their status and scores.
• The first entry of address is the venue name; the second is usually the neighborhood.

---

🚀 Ready to scrape Google Events?

Whether you're wiring this up as an MCP tool for Claude, ChatGPT, or Cursor, or pulling event data directly through Apify's API, you'll have clean, structured Google Events results in minutes. Click Try for free to run your first search.

Python + MCP example: Apify-Google-Events-API on GitHub

Made with ❤️

---

n8n integration

Available as an n8n community node, n8n-nodes-google-events-api. In n8n: Settings, Community Nodes, install n8n-nodes-google-events-api, then use it in any workflow (it also works as an AI Agent tool).

---

Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

• Find concerts and festivals in Austin this weekend - live events for the coming weekend with types, dates, and venues.
• Track tech conferences in San Francisco - upcoming conferences with types, dates, and venues for event marketers.
• Aggregate local sports events for a city app - one run returns a city's games with types, dates, and venues as JSON.
• Track Google Events for a City on a Schedule - re-run a saved city search to catch new listings, with type, date, and venue.
• Give an AI Agent Live Google Events Data via MCP - let a Claude (free trial available) or ChatGPT agent pull live events over MCP, with type, date, and venue.

---

📚 Guides and Tutorials

In-depth walkthroughs for this API, published on Medium.

Google Events API for AI Agents: Live Concerts, Conferences and Tickets via MCP

A walkthrough of using the Google Events API with AI agents over MCP, centered on the search "google events api" and live concert and conference data. It covers how to wire the API into an assistant like Claude or ChatGPT. Published July 2026. Since November 2026 the listing surface is back, so the field list it shows is close to what the API returns today again; see What changed in 2026.

---

🌐 About Alpha OSINT

This Actor is part of Alpha OSINT, toolset of financial and operations data sources and APIs. See the Google Events source page for related tools and use cases. For support or requests for this actor, please start a ticket directly on our support page.

Last Updated: 2026.11.15