Google Events API & Scraper — Local Event Listings

Google Events API & Scraper searches Google for events by topic and city and returns each event card as JSON: event title, displayed date and time, parsed start date, event type, venue, locality, card description, ticket link when Google shows one, and the Google search URL it came from. It is built for local-event apps, newsletters, calendar assistants, and AI agents, and costs about USD 5 per 1,000 event records on the Apify FREE tier (USD 4 per 1,000 on GOLD and above).

You give it up to five topics such as concerts or tech meetups, a location such as Austin, TX, and an optional date window. It reads the events Google shows in its regular search results (about 4 per results page; with the any date window it also reads the today, tomorrow, this-weekend, next-week and this-month views of each topic), removes duplicates, and returns one record per event through the Apify API, MCP, or a dataset export (JSON, CSV, Excel).

Is there a Google Events API?

Google does not offer a public API for the event listings it shows in Search; the Google Calendar API only works with calendars you have access to. This Actor fills that gap: you send a topic, location, and date window, and you get structured JSON back from a hosted run, without parsing Google result pages yourself.

What does Google Events API & Scraper return?

Each event is one record with 18 fields. Optional fields are always present and are null when Google does not show the value.

Field	What it contains
eventId	Stable hash used to deduplicate events across your queries
title	Event name, for example Judah & The Lion
dateText	Date and time as displayed, for example Today · Oct 27, 7:45 PM
startDate	Venue-local start parsed from the displayed date, for example 2026-10-27T19:45:00 (no time-zone offset; the year is inferred because Google omits it); null when no month and day are shown
endDate	Only when the page carries structured event data; otherwise null
eventType	Event-type line from the card, for example Rock and roll concert; null when the card shows none
venue	Venue name, for example Webster Hall
address	Locality line under the venue, for example New York, NY
organizer	Organizer, when structured event data names one
description	Card text in detailed mode; null in concise mode
imageUrl	Event image, when the card links one
ticketUrl	External ticket or event page, when the card links one
sourceUrl	The Google search URL that produced the record
query, locationQuery, dateFilter	The topic, location, and date window you asked for
scrapedAt, warnings	Collection time and any per-record warnings

How do I find local events by city and date?

Put topics in searchQueries, a city or region in location, and choose a dateFilter.

{
  "searchQueries": ["live jazz", "comedy shows"],
  "location": "Chicago, IL",
  "dateFilter": "this_weekend",
  "maxResults": 40,
  "responseFormat": "detailed"
}

• Topics: 1 to 5 per run, 2 to 120 characters each. Each Google search has the form "live jazz in Chicago, IL this weekend".
• Location: any human-readable place, for example London, UK or Toronto, Canada. Searches run on Google's US-English interface, so dates and labels come back in English.
• Date window: any, today, tomorrow, this_weekend, this_week, next_week, or this_month. It is added to the search as words, so treat it as a hint and check dateText. A specific window reads one results page per topic; any reads up to six (the plain search plus five date views) until maxResults is reached.
• maxResults: 1 to 100 across all topics (default 25).
• responseFormat: concise drops descriptions for smaller agent payloads; detailed (default) keeps them.
• requestDelayMs: optional pause between batches of Google searches, 0 to 10,000 ms (default 0, no pause).

Call it from code

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/google-events').call({
    searchQueries: ['technology conferences'],
    location: 'Berlin, Germany',
    dateFilter: 'next_week',
    maxResults: 20,
    responseFormat: 'concise',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((e) => `${e.dateText} | ${e.title} | ${e.address}`));

from apify_client import ApifyClient

client = ApifyClient("MY_APIFY_TOKEN")
run = client.actor("muhammadafzal/google-events").call(run_input={
    "searchQueries": ["food festivals"],
    "location": "Austin, TX",
    "dateFilter": "this_month",
    "maxResults": 25,
})
events = client.dataset(run.default_dataset_id).list_items().items

Use it from an AI assistant

Google Events API & Scraper works from Claude, ChatGPT, Cursor, or any MCP client through Apify's MCP server. Add https://mcp.apify.com/?tools=muhammadafzal/google-events as a server and ask in plain language, for example: "What concerts are on in New York this weekend? List the title, date, and venue with a ticket link if there is one." The assistant sees the input fields and the price per event before it runs the tool.

What does the output look like?

Two records from the default run (concerts, New York, NY) on 2026-11-04, which read 6 results pages:

[
  {
    "eventId": "evt_e32f0e865e45",
    "title": "Ella Red",
    "startDate": "2026-11-07T19:00:00",
    "endDate": null,
    "dateText": "Sat, Nov 7 · Nov 7, 7:00 PM",
    "eventType": "Live music concert",
    "venue": "Irving Plaza",
    "address": "New York, NY",
    "organizer": null,
    "description": "Sat, Nov 7Live music concertNov 7, 7:00 PMIrving PlazaNew York, NY",
    "imageUrl": null,
    "ticketUrl": null,
    "sourceUrl": "https://www.google.com/search?q=concerts+events+in+New+York%2C+NY+this+weekend&hl=en&gl=us",
    "query": "concerts",
    "locationQuery": "New York, NY",
    "dateFilter": "any",
    "scrapedAt": "2026-11-04T02:07:51.693Z",
    "warnings": []
  },
  {
    "title": "Hadestown",
    "startDate": "2026-11-04T19:30:00",
    "dateText": "Tomorrow · Nov 4, 7:30 PM",
    "eventType": null,
    "venue": "Walter Kerr Theatre",
    "address": "New York, NY",
    "ticketUrl": null,
    "query": "concerts"
  }
]

Each run also writes OUTPUT to the key-value store: outcome (DATA, EMPTY, BLOCKED, or FAILED), record and charge counts, pages requested, finished, and failed, pages per access route, date-view pages added and skipped, duplicate showings skipped, pages from another area skipped, the stop reason, and warnings.

Pricing: how much do 1,000 Google event records cost?

You pay per event record stored, plus a start fee. Platform usage is included in these prices.

Event	FREE	BRONZE	SILVER	GOLD	PLATINUM	DIAMOND
Google event record (each event)	$0.005001	$0.004875	$0.00475	$0.004	$0.004	$0.004
Actor start, per started GB of allocated memory	$0.006251	$0.006094	$0.005938	$0.005	$0.005	$0.005

The default run uses 256 MB, so it pays one start event. Worked totals:

• A default run that returns 20 events, on FREE: $0.006251 + 20 × $0.005001 = $0.1063.
• 100 events (the run maximum) on GOLD: $0.005 + 100 × $0.004 = $0.405.

A blocked or empty search pays the start fee only. Set maxResults and Apify's maximum total charge per run to bound spend.

When should I use it, and when not?

Use it when you need:

• a quick list of what is on in a city for a topic, for a newsletter, chatbot, or travel guide;
• event discovery across Google's aggregated sources, with the Google search URL for provenance;
• a small, scheduled refresh of local events for an AI agent.

Use something else when you need:

• events from one ticketing platform with full detail: Eventbrite Event Scraper;
• public Facebook events: Facebook Events Scraper;
• time-zone-aware timestamps, prices, or ticket inventory for every event, or a complete city calendar: this Actor does not provide them.

Limits and known data gaps

• Google shows about 4 events per results page and has no further pages for its event cards. With dateFilter: any, the default concerts search in New York read 6 pages and returned about 20 events on 2026-11-04, so expect roughly 10–30 events per topic, not 100; with a specific date window, expect about 4 per topic.
• startDate is venue-local time without an offset, and its year is inferred. endDate, organizer, imageUrl and ticketUrl were null on every record of that run, because Google's current cards do not show them.
• Only Google's event cards are saved. Summary passages, related searches and web results, such as a "Tonight and This Weekend" list, are skipped and never charged.
• Each search names events (jazz becomes "jazz events in Austin, TX"), because Google shows its event cards on more pages that way. A topic that already says "event" or "events" is searched as written.
• The same show on two dates is two records (for example two SIX performances). When Google lists one showing twice, under a full and a shorter title at the same venue and start time ("SIX on Broadway" and "Six"), it is saved and charged once.
• Google shows its event cards on some requests and not on others, even for the same search, so the event count for a topic varies from run to run.
• If Google does not recognize the location, it may show events near the requester instead. When location names a US state (Austin, TX or Austin, Texas) and every event on a page is in another state, that page's events are not saved or charged.
• If Google answers with an access check, the run stops the remaining topics, reports BLOCKED in OUTPUT, and makes no event charges.
• A topic's remaining date views are skipped after two views in a row add no new event, and the run requests only the pages the remaining maxResults need.
• The default run took about 90 seconds (6 results pages, up to 4 at a time).

FAQ

Does Google have an official Events API?

No public one for Search event listings. The Google Calendar API covers calendars you have access to, not the events Google shows in results. This Actor returns those results as JSON.

How many events does one search return?

About 4 per results page. With dateFilter: any the Actor reads up to six date views per topic, which gave about 20 events for concerts in New York. Add more topics (up to five) or run several locations for broader coverage.

Why is endDate empty?

Google's event cards show only a start date and time. startDate is parsed from that text (venue-local, year inferred); endDate is filled only when the page includes structured event data. dateText keeps the date exactly as Google displays it.

Can I search events outside the United States?

Yes. Put any city in location, for example Paris, France. Searches run on Google's US-English interface, so labels and dates are in English.

Am I charged when Google blocks a search?

You are not charged for events. The start fee still applies, and OUTPUT shows the BLOCKED outcome.

Do I need a Google API key or my own proxy?

No. The Actor handles data access itself.

Can an AI agent run this Actor by itself?

Yes. Through Apify's MCP server an agent reads the input schema and the price per event, runs the Actor, and receives the dataset. Use responseFormat: "concise" to keep its context small.

Related Actors

• Eventbrite Event Scraper: events and ticket details from Eventbrite.
• Facebook Events Scraper: public Facebook event search.
• Google News Scraper & API: headlines about a venue, artist, or city.
• From the same jobs, events, news, and reviews collection: Jobspresso Remote Jobs Scraper, FreightWaves News Scraper, Google Play Reviews Scraper, and Blind Company Reviews & Salary Scraper.

Compliance note

The Actor reads public search results only. It does not sign in, buy tickets, or bypass access checks, and it is not affiliated with Google. Verify dates, prices, and ticket links with the organizer before you publish or buy.

Last verified: 2026-11-04