Google has many results for your search keywords. It's not a surprise that Google can give you a list of activities and events results when you search: "Events in Austin".
There are many types of Google Events: concerts, festivals, sports games, conferences, local meetups, and other gatherings or happenings.
Google Events is valuable data for you to discover local activities that allow users to explore what's going on in their city or regions. For organizers and promoters, this is one of the best marketing tools to increase visibility when listing on Google Events to attract more attendees.
Furthermore, Google Events can show essential information about events, users can quickly access and visit websites to buy the tickets.
Google Events also provides user reviews and ratings. Searching on Google Events gives you a hint of trending community and more review insights to help you organize new events or improve your services. It's helpful for both organizers and attendees.
Getting Started with SerpApi
You need a SerpApi account to use the Google Events API. If you have not already created one, register for a SerpApi account, verify your email address, and copy your private API key from the account dashboard.
Keep your API key out of public source code. Store it in an environment variable or a secrets manager, especially when publishing an application or sharing a repository. If a key is accidentally exposed, you can regenerate it from the SerpApi dashboard.
Install a SerpApi library
SerpApi provides official libraries for Python, JavaScript, Ruby, Java, and other languages. These libraries wrap the HTTP API and make it easier to pass parameters and work with the JSON response.
You can also call the API with a regular GET request using cURL, fetch() in Node.js, or any HTTP client. This guide covers both direct requests and several official integrations.
The Google Events API documentation lists all supported search parameters, filters, response fields, and code examples. You can also experiment with every parameter in the interactive playground before writing any code.

How to Scrape Google Events Results
The main parameters for the Google Events API are:
engine(required): set togoogle_eventsq(required): your search queryapi_key(required): your SerpApi private key
GET request
The Google Events API endpoint is https://serpapi.com/search?engine=google_events. Add your search query in q and your API key. JSON is the default output:
https://serpapi.com/search?engine=google_events&q=Events+in+Austin&api_key=YOUR_SERPAPI_API_KEY
If you want a more readable response, add output=md to get the same results as Markdown:
https://serpapi.com/search?engine=google_events&q=Events+in+Austin&output=md&api_key=YOUR_SERPAPI_API_KEYSerpApi's Markdown output is built for LLMs and AI agents. It's a curated, token-efficient view of the results, and it leaves out some nested details. Use JSON when you need exact field access, like in the code samples below.
cURL
Here is the same request in cURL. --data-urlencode takes care of the spaces in the query:
curl --get https://serpapi.com/search \
--data-urlencode 'engine=google_events' \
--data-urlencode 'q=Events in Austin' \
--data-urlencode 'api_key=YOUR_SERPAPI_API_KEY'
Python
First, you need to install the SerpApi client library.
pip install serpapiSet up the SerpApi credentials and search:
import os
import serpapi
client = serpapi.Client(api_key=os.environ["SERPAPI_API_KEY"])
results = client.search({
"engine": "google_events",
"q": "Events in Austin",
"hl": "en",
"gl": "us",
})
events = results.get("events_results", [])
print(f"Found {len(events)} events\n")
for i, event in enumerate(events, start=1):
date = event.get("date", {})
venue = event.get("venue", {}).get("name", "Venue unknown")
address = ", ".join(event.get("address", [])) or "Address unknown"
print(f"{i}. {event.get('title')}")
print(f" When: {date.get('when', 'TBD')}")
print(f" Where: {venue}")
print(f" {address}")
print("-" * 60)Run it with:
python main.py
Here is what this output will look like:

Ruby
For Ruby, use the official SerpApi Ruby library. Install it:
gem install serpapiCreate a file called main.rb and add:
require 'serpapi'
client = SerpApi::Client.new(
engine: 'google_events',
api_key: ENV.fetch('SERPAPI_API_KEY')
)
results = client.search(q: 'Events in Austin')
abort('SerpApi returned an error for this search.') if results[:error]
events = results[:events_results] || []
if events.empty?
puts 'No events found for this search.'
else
puts "Found #{events.length} events\n\n"
end
events.each.with_index(1) do |event, i|
venue = event.dig(:venue, :name) || 'Venue unknown'
address = (event[:address] || []).join(', ')
address = 'Address unknown' if address.empty?
puts "#{i}. #{event[:title]}"
puts " When: #{event.dig(:date, :when) || 'TBD'}"
puts " Where: #{venue}"
puts " #{address}"
puts '-' * 60
end
client.closeRun it with:
ruby main.rbNote: The Ruby library returns results as aHashwith symbol keys, so you read fields likeresults[:events_results]andevent[:title].
Results should look like:

JavaScript and Node.js
For JavaScript and Node.js, we'll use the official SerpApi package.
Install it:
npm install serpapiCreate a file called main.js and add:
async function main() {
const { getJson } = await import('serpapi');
const apiKey = process.env.SERPAPI_API_KEY;
if (!apiKey) {
throw new Error('Set the SERPAPI_API_KEY environment variable first.');
}
const results = await getJson({
engine: 'google_events',
q: 'Events in Austin',
api_key: apiKey,
});
if (results.error) {
throw new Error('SerpApi returned an error for this search.');
}
const events = results.events_results || [];
if (events.length === 0) {
console.log('No events found for this search.');
} else {
console.log(`Found ${events.length} events\n`);
}
events.forEach((event, i) => {
const venue = (event.venue && event.venue.name) || 'Venue unknown';
const address = (event.address || []).join(', ') || 'Address unknown';
const when = (event.date && event.date.when) || 'TBD';
console.log(`${i + 1}. ${event.title}`);
console.log(` When: ${when}`);
console.log(` Where: ${venue}`);
console.log(` ${address}`);
console.log('-'.repeat(60));
});
}
main().catch((error) => {
console.error('Request failed:', error.message);
process.exit(1);
});Run it with:node main.js
Results should look like:

Other languages and no-code solutions
You can call the API with a plain GET request from any language.
SerpApi also has official libraries for other languages, listed on the integrations page. There are no-code options too, like the Make.com app and the n8n verified node.
To see more information about scraping Google Events, check out this video:
Introducing Google Events Details
If you want more information about one specific upcoming event, you can now query the Google Events Details API to gather specifics of any event using is returned event_token.
What can you scrape with the Google Events Details API?
The Google Event Details API extracts comprehensive information from an event profile, including:
- Core Event Information
- Event title and overview: The official name, tour or series title, and full promotional description provided by organizers.
- Date and scheduling: Exact start dates, times, multi-day scheduling, and human-readable timeframes.
- Location and Venue Details
- Physical location: Full street address, city, state, postal code, and country.
- Venue profile: Name of the stadium, hall, or arena, along with its overall Google rating, user review counts, and venue background notes.
- Map references: Interactive map links, static map previews, and precise GPS coordinates for mapping and navigation apps.
- Ticketing and Booking Options
- Vendor sources: Names of primary ticket sellers, secondary marketplaces, or direct venue box offices.
- Booking links: Direct URLs to purchasing pages, ticket tiers, and admission details.
- Contextual Discovery (Optional Add-ons)
- Nearby points of interest: Local attractions, restaurants, landmarks, and accommodations surrounding the venue.
- Similar and related events: Recommendations for related performances, artists, or nearby events, including unique identifiers to chain additional lookups.
- Contextual web results: Relevant organic search snippets and articles associated directly with the event card.How to scrape with the Google Events Results API
How to scrape Google Events Details API?
Assuming you have already followed the steps above and registered your SerpApi account, you first need to confirm your search parameters.
The main ones are:
event_token(required): the token fromevents_resultsgl(optional): two-letter country code. Defaults tous. It sets the date format, price currency, and can change which ticket sellers are listedhl(optional): language code. Defaults toennearby_places(optional): set to1ortrueto get up to 10 places near the venuesimilar_events(optional): set to1ortrueto get related events, each with its ownevent_tokensearch_results(optional): set to1ortrueto get a short list of web results about the event
Finding the event_token
Every event in the Events API's events_results includes an event_token and a ready-made serpapi_event_details_link. Use either one. The token is time-sensitive, so for the most complete results (ticket information, for example), use it soon after you get it.
In the examples below, we'll use the event_token of the first event returned by the Events API call above. Run that search, copy the token from the first item in events_results, and paste it where you see YOUR_EVENT_TOKEN.
GET request
The GET request looks like this (URL-encode the token if you build the URL by hand):
https://serpapi.com/search?engine=google_event_details&event_token=YOUR_EVENT_TOKEN&similar_events=true&api_key=YOUR_SERPAPI_API_KEYResults should look like:

cURL
The equivalent cURL request:
curl --get https://serpapi.com/search \
--data-urlencode 'engine=google_event_details' \
--data-urlencode 'event_token=YOUR_EVENT_TOKEN' \
--data-urlencode 'similar_events=true' \
--data-urlencode 'api_key=YOUR_SERPAPI_API_KEY'The results should look like:

Python
Create a new file called event_details.py.
Replace YOUR_EVENT_TOKEN with the token from the first event of your Events search. Use a fresh token, since they are time-sensitive.
async function main() {
const { getJson } = await import('serpapi');
const apiKey = process.env.SERPAPI_API_KEY;
if (!apiKey) {
throw new Error('Set the SERPAPI_API_KEY environment variable first.');
}
const results = await getJson({
engine: 'google_event_details',
event_token: 'YOUR_TOKEN_HERE',
similar_events: true,
api_key: apiKey,
});
if (results.error) {
throw new Error(results.error);
}
const info = results.event_details || {};
console.log(info.title);
console.log(' When:', info.date && info.date.when);
console.log(' Venue:', info.venue && info.venue.name);
for (const seller of info.ticket_info || []) {
console.log(' Tickets via:', seller.source);
}
for (const similar of (info.similar_events || []).slice(0, 3)) {
console.log(' Similar:', similar.title);
}
}
main().catch((error) => {
console.error('Request failed:', error.message);
process.exit(1);
});Run it with:
python event_details.pyResults should look like:

Ruby
Create a file called event_details.rb:
require 'serpapi'
client = SerpApi::Client.new(
engine: 'google_event_details',
api_key: ENV.fetch('SERPAPI_API_KEY')
)
details = client.search(event_token: 'YOUR_EVENT_TOKEN', similar_events: 'true')
abort('SerpApi returned an error for the event details.') if details[:error]
info = details[:event_details] || {}
puts info[:title]
puts " When: #{info.dig(:date, :when)}"
puts " Venue: #{info.dig(:venue, :name)}"
(info[:ticket_info] || []).each { |seller| puts " Tickets via: #{seller[:source]}" }
(info[:similar_events] || []).first(3).each { |similar| puts " Similar: #{similar[:title]}" }
client.closeRun it with:
ruby event_details.rbResults should look like:

JavaScript and Node.js
Create a file called event_details.js and paste in your own event_token:
async function main() {
const { getJson } = await import('serpapi');
const apiKey = process.env.SERPAPI_API_KEY;
if (!apiKey) {
throw new Error('Set the SERPAPI_API_KEY environment variable first.');
}
const details = await getJson({
engine: 'google_event_details',
event_token: 'YOUR_EVENT_TOKEN',
similar_events: 'true',
api_key: apiKey,
});
if (details.error) {
throw new Error('SerpApi returned an error for the event details.');
}
const info = details.event_details || {};
console.log(info.title);
console.log(' When:', info.date && info.date.when);
console.log(' Venue:', info.venue && info.venue.name);
}
main().catch((error) => {
console.error('Request failed:', error.message);
process.exit(1);
});Run it with node event_details.js.
Results should look like:

Other languages and no-code solutions
The same request works from any language with a plain GET request. Check the integrations page for the other official libraries.
Scraping Event Data
Want to go discover more about scraping Google Events?
These SerpApi tutorials cover more:
- Filter and Scrape Google Events with Python: filter events by location, date, and query wording.
- Scrape Google Events Results with Python: a step-by-step Python tutorial.
- Web Scraping Google Events Results with Nodejs: a step-by-step Node.js tutorial.
Conclusion
With the Google Events API you can pull a list of events for any search, and with the Google Event Details API you can follow each event_token to get tickets, venue info, similar events, and more. You can keep experimenting in the Events playground and the Event Details playground.