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

A typical Google Events results page

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.

The JSON result for Google Events

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.

SerpApi's documentation page for the Google Events API

How to Scrape Google Events Results

The main parameters for the Google Events API are:

  • engine (required): set to google_events
  • q (required): your search query
  • api_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
The GET results from calling the Google Events API

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_KEY

SerpApi'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'
The results for the above cURL call

Python

First, you need to install the SerpApi client library.

pip install serpapi

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

The above Python code's results

Ruby

For Ruby, use the official SerpApi Ruby library. Install it:

gem install serpapi

Create 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.close

Run it with:

ruby main.rb
Note: The Ruby library returns results as a Hash with symbol keys, so you read fields like results[:events_results] and event[:title].

Results should look like:

The above Ruby code's results

JavaScript and Node.js

For JavaScript and Node.js, we'll use the official SerpApi package.

Install it:

npm install serpapi

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

The above JavaScript code's results

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 from events_results
  • gl (optional): two-letter country code. Defaults to us. It sets the date format, price currency, and can change which ticket sellers are listed
  • hl (optional): language code. Defaults to en
  • nearby_places (optional): set to 1 or true to get up to 10 places near the venue
  • similar_events (optional): set to 1 or true to get related events, each with its own event_token
  • search_results (optional): set to 1 or true to 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_KEY

Results should look like:

The results of the above GET request

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:

The results of the above cURL call

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

Results should look like:

The results of the above Python code

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

Run it with:

ruby event_details.rb

Results should look like:

The results of the above Ruby code

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:

The results of the above JavaScript code

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:

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.