# Google Events Scraper (`automation-lab/google-events-scraper`) Actor

📅 Extract Google Events search results into structured event records with titles, dates, venues, locations, source links, and ticket URLs.

- **URL**: https://apify.com/automation-lab/google-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Events Scraper

Extract structured event records from Google Events search results for local marketing, SEO research, event discovery, and competitor intelligence.

### What does Google Events Scraper do?

Google Events Scraper searches Google Events for one or more queries and saves normalized event records to an Apify dataset.

It is designed for searches such as:

- `tech events in Austin this week`
- `concerts in Berlin this weekend`
- `marketing conferences in New York`
- `family events near Seattle this month`

The actor focuses on event cards, not generic Google organic results.

### Who is it for?

Local marketers use it to monitor events in target cities.

Event aggregators use it to seed calendars and newsletters.

SEO teams use it to discover event-rich-result competitors.

Venue teams use it to watch similar venues and nearby events.

Agencies use it to collect leads for sponsors, partnerships, and outreach.

### Why use this actor?

Google Events combines many event sources into one rich-results experience.

Instead of scraping dozens of event websites separately, you can start with the events Google already surfaces for a query.

The actor returns consistent fields that are easier to export, filter, enrich, and send to downstream tools.

### What data can you extract?

| Field | Description |
| --- | --- |
| query | Search query that produced the event |
| position | Event rank within the query |
| title | Event title |
| dateText | Date or date range displayed by Google |
| startDate | Parsed ISO date when possible |
| timeText | Displayed event time |
| venueName | Venue or host candidate |
| locationText | Location/address text |
| city | Parsed city when obvious |
| description | Short snippet when visible |
| eventUrl | Source event URL when exposed |
| ticketUrl | Ticket/register/RSVP URL when detected |
| imageUrl | Event image when present |
| isOnline | Online/virtual event signal |
| scrapedAt | Extraction timestamp |

### How much does it cost to scrape Google Events?

The actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-event charge for records saved to the dataset.

Use low `maxEventsPerQuery` values while testing new searches.

Google SERP proxy traffic is expensive, so the actor avoids blind retries on block pages.

### How to use Google Events Scraper

1. Open the actor on Apify.
2. Add one or more Google Events queries.
3. Choose a date range.
4. Set a small maximum events per query for a first run.
5. Start the actor.
6. Export results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

`queries` is required.

Include the target city or region inside each query.

`maxEventsPerQuery` controls cost and output volume.

`dateRange` applies Google Events date chips.

`country` controls Google localization and proxy country.

`language` controls result language.

`includeTicketLinks` enables ticket/register link classification.

### Example input

```json
{
  "queries": ["tech events in Austin this week"],
  "maxEventsPerQuery": 10,
  "dateRange": "week",
  "country": "us",
  "language": "en",
  "includeTicketLinks": true
}
````

### Example output

```json
{
  "query": "tech events in Austin this week",
  "position": 1,
  "title": "Austin tech meetup",
  "dateText": "Thu, Jun 20",
  "startDate": null,
  "timeText": "6:00 PM",
  "venueName": "Downtown Austin",
  "locationText": "Austin, TX",
  "eventUrl": "https://example.com/event",
  "ticketUrl": "https://example.com/register",
  "scrapedAt": "2026-06-18T18:00:00.000Z"
}
```

### Tips for better results

Use specific city names.

Add event category words such as conference, concert, meetup, festival, workshop, or webinar.

Use `weekend` for entertainment searches.

Use `month` for conference and trade-show searches.

Run several focused queries instead of one broad query.

Start with 10 events per query, then scale after reviewing output.

### Handling Google blocks

Google can show CAPTCHA, consent, or anti-bot pages.

When that happens, the actor logs a warning and skips the blocked query.

This protects your run from retry loops and unnecessary proxy spend.

If a query returns no data, try a more specific location or a different date range.

### Integrations

Send event data to Google Sheets for editorial planning.

Send event data to Airtable for calendar workflows.

Use Zapier or Make to trigger outreach campaigns.

Use the Apify API to refresh event feeds daily.

Use dataset webhooks to update dashboards.

Join event results with venue enrichment actors.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-events-scraper').call({
  queries: ['concerts in Austin this weekend'],
  maxEventsPerQuery: 10,
  dateRange: 'weekend',
  country: 'us',
  language: 'en'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/google-events-scraper').call(run_input={
    'queries': ['marketing events in New York this month'],
    'maxEventsPerQuery': 10,
    'dateRange': 'month',
    'country': 'us',
    'language': 'en',
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~google-events-scraper/runs?token=MY_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["startup events in San Francisco this week"],"maxEventsPerQuery":10,"dateRange":"week","country":"us","language":"en"}'
```

### MCP usage

Use this actor from MCP-compatible AI tools through Apify MCP Server.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/google-events-scraper`

Claude Code setup:

```bash
claude mcp add apify-google-events "https://mcp.apify.com/?tools=automation-lab/google-events-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-google-events": {
      "url": "https://mcp.apify.com/?tools=automation-lab/google-events-scraper"
    }
  }
}
```

Example prompt:

> MCP usage: use the Apify Google Events Scraper MCP tool to find tech events in Austin this week and summarize the top venues.

Example Claude Desktop prompt:

> Use Google Events Scraper to collect marketing conferences in New York this month, then group them by date.

Example MCP automation prompt:

> MCP usage: run automation-lab/google-events-scraper for concerts in Berlin this weekend, export the dataset, and highlight ticket links.

### Common workflows

Build a weekly local events newsletter.

Monitor competitor venues.

Find sponsorship opportunities.

Track event SEO visibility.

Create city-specific content calendars.

Discover conferences for sales teams.

Collect event leads for enrichment.

### Data quality notes

Google changes markup frequently.

Some fields may be null when Google does not expose them in the visible event card.

`dateText` is the safest date field because it preserves Google's display text.

`startDate` is best-effort parsing and should be reviewed before calendar automation.

### Legality

This actor extracts publicly visible search-result information.

Respect Google terms, website terms, privacy rules, and applicable laws.

Do not use the output for spam or prohibited profiling.

Only collect and process data you have a lawful basis to use.

### FAQ

#### Is this a Google Events API?

It is an Apify actor that extracts event-like records from Google Events/search result pages. It does not require a separate Google API key.

#### Why are some fields null?

Google does not expose every date, venue, ticket link, or image in every result. The actor preserves visible values and leaves unavailable fields as null.

### Troubleshooting: no events returned

Try a more specific query.

Include a city or region.

Change the date range.

Lower the maximum events while testing.

Check the run log for Google block or consent warnings.

### Troubleshooting: missing ticket links

Google may not expose ticket links for every event card.

Enable `includeTicketLinks`.

Check `eventUrl`, because the ticket flow may be on the source page.

Run venue/source enrichment after export if you need guaranteed purchase URLs.

### Related scrapers

Use `https://apify.com/automation-lab/google-search-scraper` for organic Google results.

Use `https://apify.com/automation-lab/google-maps-scraper` for local business discovery.

Use `https://apify.com/automation-lab/eventbrite-scraper` for Eventbrite listings.

Use `https://apify.com/automation-lab/meetup-scraper` for Meetup events.

Use `https://apify.com/automation-lab/allevents-scraper` for AllEvents listings.

### Limitations

The actor does not guarantee every event available on Google.

It does not log in to Google.

It does not bypass CAPTCHA pages.

It does not scrape full event detail pages in the MVP.

It extracts what is visible in the event-rich-result page.

### Changelog

Initial version extracts Google Events cards by query, date range, country, and language.

### Support

If a run fails, include the run ID and input when reporting the issue.

Small reproducible inputs are easiest to debug.

### Output exports

Apify datasets can be exported as JSON.

Apify datasets can be exported as CSV.

Apify datasets can be exported as Excel.

Apify datasets can be exported as XML.

Apify datasets can be exported as RSS.

### Performance guidance

Use focused queries.

Keep first runs small.

Avoid hundreds of broad searches in one run.

Review block warnings before scaling.

### Event query examples

`jazz concerts in Chicago this weekend`

`startup pitch events in London this month`

`family events in Denver today`

`AI conferences in San Francisco this month`

`food festivals near Austin this weekend`

# Actor input Schema

## `queries` (type: `array`):

One or more Google Events searches. Include the location in each query, for example: 'tech events in Austin' or 'concerts in Berlin this weekend'.

## `maxEventsPerQuery` (type: `integer`):

Maximum number of event records to save for each search query.

## `dateRange` (type: `string`):

Google Events date chip to apply to each query.

## `country` (type: `string`):

Two-letter country code used for Google localization and proxy country selection.

## `language` (type: `string`):

Two-letter language code for Google search results.

## `includeTicketLinks` (type: `boolean`):

When enabled, the scraper tries to identify ticket, registration, RSVP, or purchase links exposed in the event card.

## Actor input object example

```json
{
  "queries": [
    "tech events in Austin this week"
  ],
  "maxEventsPerQuery": 10,
  "dateRange": "week",
  "country": "us",
  "language": "en",
  "includeTicketLinks": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "queries": [
        "tech events in Austin this week"
    ],
    "maxEventsPerQuery": 10,
    "dateRange": "week",
    "country": "us",
    "language": "en",
    "includeTicketLinks": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "queries": ["tech events in Austin this week"],
    "maxEventsPerQuery": 10,
    "dateRange": "week",
    "country": "us",
    "language": "en",
    "includeTicketLinks": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "tech events in Austin this week"
  ],
  "maxEventsPerQuery": 10,
  "dateRange": "week",
  "country": "us",
  "language": "en",
  "includeTicketLinks": true
}' |
apify call automation-lab/google-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/google-events-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Events Scraper",
        "description": "📅 Extract Google Events search results into structured event records with titles, dates, venues, locations, source links, and ticket URLs.",
        "version": "0.1",
        "x-build-id": "Pd5Yp9Mqt5LEYnfg7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~google-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~google-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Google Events queries",
                        "type": "array",
                        "description": "One or more Google Events searches. Include the location in each query, for example: 'tech events in Austin' or 'concerts in Berlin this weekend'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEventsPerQuery": {
                        "title": "Maximum events per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of event records to save for each search query.",
                        "default": 25
                    },
                    "dateRange": {
                        "title": "Date range",
                        "enum": [
                            "all",
                            "today",
                            "tomorrow",
                            "week",
                            "weekend",
                            "month"
                        ],
                        "type": "string",
                        "description": "Google Events date chip to apply to each query.",
                        "default": "week"
                    },
                    "country": {
                        "title": "Google country code",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter country code used for Google localization and proxy country selection.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Google language code",
                        "minLength": 2,
                        "maxLength": 5,
                        "type": "string",
                        "description": "Two-letter language code for Google search results.",
                        "default": "en"
                    },
                    "includeTicketLinks": {
                        "title": "Extract ticket/register links",
                        "type": "boolean",
                        "description": "When enabled, the scraper tries to identify ticket, registration, RSVP, or purchase links exposed in the event card.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
