# Google Events Search Scraper — Local & Online Events (`sian.agency/google-events-search-scraper`) Actor

Search Google Events for local concerts, conferences, workshops and other public events. One record contains the completed search, event count and complete returned event list with available date and venue information. Export JSON or CSV.

- **URL**: https://apify.com/sian.agency/google-events-search-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Travel, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $125.72 / 1,000 completed event search records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Events Search Scraper — Local & Online Events 🎟️

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Google News](https://img.shields.io/badge/Store-Google%20News-4285F4)](https://apify.com/sian.agency/google-news-scraper?fpr=sian) [![Local Business Data](https://img.shields.io/badge/Store-Local%20Business%20Data-1AE392)](https://apify.com/sian.agency/local-business-data-scraper?fpr=sian) [![Google Search](https://img.shields.io/badge/Store-Google%20Search-4285F4)](https://apify.com/sian.agency/google-serp-scraper?fpr=sian)

#### 🎟️ One search record, every returned event included

##### For local publishers, researchers and teams maintaining event discovery lists

### 🔎 What is the Google Events Search Scraper — and when should you use it?

The **Google Events Search Scraper** turns Google Events search records with dates, venues and complete event lists into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** you need event discovery results for a location or topic.

**Use something else when:** you need business listings or venue reviews. Use [Local Business Data Scraper](https://apify.com/sian.agency/local-business-data-scraper?fpr=sian) for business and venue listings. This actor searches events; it does not verify ticket availability.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/google-events-search-scraper

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. One completed search is charged, including a valid empty observation. All events are included in that record. Failed retrievals have no search-event charge; a separate run-start fee applies.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want a local event discovery list using the Apify Actor `sian.agency/google-events-search-scraper`.

Use it when I need: you need event discovery results for a location or topic.

Don't use it when: you need business listings or venue reviews — use local-business-data-scraper instead.

How to call it: set operation to search and provide query. Optionally set dateHint as a search preference. Read events inside the single completed-search record.

Start with this input:
{
  "operation": "search",
  "query": "concerts in San Francisco",
  "dateHint": "any"
}

Ask me which events and city they want to research, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Find concerts in San Francisco and list the returned dates and venues.*
- *Research conferences and export the complete event list as JSON.*
- *Record whether a specific event search currently returns any listings.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/google-events-search-scraper.md](https://apify.com/sian.agency/google-events-search-scraper.md).

### 📋 Overview

Google Events Search Scraper turns one event query into a structured search record. It includes the event count, names, available date labels, venues and the complete returned event list.

Use it to start a local calendar or research a topic. Check listings before publishing or booking; the search does not verify tickets or guarantee coverage.

- ✅ **One billing unit:** A completed search costs one event, whether it returns zero, one or several listings.
- 🎟️ **Complete returned list:** All events from that search are included in the record.
- 📅 **Honest preferences:** The date setting steers the search. It is a hint, not a strict filter.
- 📍 **Available venue information:** Keep venue names and any other returned location details.
- 📄 **Processing report:** Review the search, result count, billing receipt and retry input.

The recorded San Francisco example returned seven named events with dates and venue names. Other fields were often absent. Results can change between runs.

### ✨ Features

- 🔎 **One query per run:** Describe an event, place or topic in your own words.
- 📅 **Date hints:** Choose today, tomorrow, week, weekend, next week, month or next month.
- 🎤 **Event names and dates:** Keep readable labels as published in the search.
- 🏢 **Venue names:** Review the locations associated with returned events.
- 📦 **Nested event records:** Preserve all returned fields in JSON, including optional links and venue data.
- 🔍 **Explicit empty observations:** A valid empty search has `empty=true`, `eventCount=0` and `events=[]`.
- 📄 **Exports:** Download JSON, CSV or Excel from the dataset.

### 🎬 Quick Start

Open the Input tab and run the supplied concerts example. Change the query to the events and place you need. One completed run produces one search record.

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/sian.agency~google-events-search-scraper/runs?token=YOUR_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{"operation":"search","query":"concerts in San Francisco","dateHint":"any"}'
```

This starts a run and returns run metadata. Wait for it to finish, then retrieve its default dataset. An empty API input does not run the Console example.

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Describe the search

Enter an event phrase and location, such as concerts in San Francisco. You can also search for a conference topic or venue.

#### Step 2: Set preferences

Keep any date for broad discovery, or choose a date hint. Check the actual date of each returned event.

#### Step 3: Read the record

Open the Dataset tab for the completed search and nested events. Open the run's Output tab for the processing report. Export JSON to retain the entire event list.

### 📥 Input Configuration

| Field | Type | Required | Description |
|---|---|---|---|
| `operation` | string | No | `search`, the only operation. |
| `query` | string | Yes | Event phrase, 1–300 characters. Include the place when relevant. |
| `dateHint` | string | No | `any`, `today`, `tomorrow`, `week`, `weekend`, `next_week`, `month` or `next_month`. |

```json
{
  "operation": "search",
  "query": "concerts in San Francisco",
  "dateHint": "any"
}
```

The query has a Console prefill and no API default. API callers must supply it. Date preferences are search hints; verify actual dates and venues in the returned events.

Free-plan users can run this actor from Apify Console or MCP. Direct API access requires a paid Apify plan. A blocked API run returns an explanatory rejected record and report with no completed-search charge; the platform run-start fee still applies.

There is one search per run. This version does not accept a query list, pagination or event-detail requests. Free and paid Apify accounts receive the same search contents; paid plans have discounted rates.

### 📤 Output

One completed-search row contains the following fields. The nested `events` array holds every returned event, without extra event charges.

| Field | Type | Description |
|---|---|---|
| `query` | string | Search phrase used for this observation. |
| `eventCount` | integer | Number of returned events. |
| `empty` | boolean | True for a completed search with no matching events. |
| `eventNames` | array | Event names in the returned order. |
| `venueNames` | array | Available venue names. |
| `dateLabels` | array | Available readable event date labels. |
| `events` | array | Complete returned event records. |
| `imageUrl` | string or null | First available event thumbnail, when provided. |
| `dateHint` | string | Requested date hint. |
| `status` / `errorMessage` | string / string or null | Outcome and failure explanation. |
| `_operation` / `_fetchedAt` | string | Operation and retrieval timestamp. |

**Recorded example, shortened to one event and selected fields:**

```json
{
  "query": "concerts in San Francisco",
  "eventCount": 7,
  "empty": false,
  "eventNames": ["Bluegrass Breeze"],
  "venueNames": ["The East Cut Community Benefit District"],
  "dateLabels": ["Oct 17, 11:30 AM"],
  "events": [{
    "name": "Bluegrass Breeze",
    "date_human_readable": "Oct 17, 11:30 AM",
    "venue": {"name": "The East Cut Community Benefit District"}
  }],
  "dateHint": "any",
  "status": "success"
}
```

The real record contains all seven events. Names and dates above illustrate the output, not future availability. Event IDs are opaque strings. Optional event links, thumbnails, descriptions, ticket links, detailed timestamps, coordinates and venue contacts can be null or absent.

A valid empty search is a successful observation with empty arrays. Retrieval failures produce an error record and no completed-search charge. JSON retains nested fields; CSV and Excel encode nested values as text.

### 💼 Use Cases & Examples

#### 1. Local publishers building a city calendar

**Input:** An event category and city.
**Output:** Event names, readable dates and venue names.
**Use:** Build a discovery list, then verify details before publication.

#### 2. Venue marketers researching nearby events

**Input:** A venue or neighborhood search.
**Output:** A saved observation and the returned event list.
**Use:** Review listings relevant to a local promotion.

#### 3. Tourism teams planning destination guides

**Input:** Concerts or festivals in a destination.
**Output:** Available dates and locations.
**Use:** Identify candidates for a visitor guide.

#### 4. Conference researchers finding relevant meetings

**Input:** A conference topic with a date hint.
**Output:** Returned conference and event listings.
**Use:** Review candidate events before checking organizer pages.

#### 5. Community managers finding workshops

**Input:** A workshop subject and location.
**Output:** Event names and available venue data.
**Use:** Suggest activities after checking whether they fit the community.

#### 6. Data analysts tracking search observations

**Input:** The same saved query on a schedule.
**Output:** Timestamped completed-search records, including empty results.
**Use:** Compare event discovery results in your own database.

### 🔗 Integration Examples

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('sian.agency/google-events-search-scraper').call({
  operation: 'search', query: 'concerts in San Francisco', dateHint: 'any',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].events);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('sian.agency/google-events-search-scraper').call(
    run_input={'operation': 'search', 'query': 'concerts in San Francisco', 'dateHint': 'any'}
)
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item.get('events', []))
```

#### cURL: retrieve a completed dataset

```bash
curl 'https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?format=json&clean=true&token=YOUR_TOKEN'
```

Use the run-start request in Quick Start, wait for completion, then use that run's dataset ID.

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger:** Schedule an event query.
2. **HTTP Request:** Start this actor with the chosen input.
3. **Process:** Wait for completion and retrieve its dataset.
4. **Action:** Save events to a spreadsheet or database and review them before publishing.

### 📊 Performance & Pricing

One **completed-search** event pays for one completed event search. Every returned event is included in that record. A valid empty search is also billed because it delivers an explicit observation for the requested query.

Failed retrievals have no completed-search charge. A separate run-start fee applies to every run, including invalid or billing-limited runs. The search must fit the remaining budget before retrieval begins.

| Apify plan | Completed search | Run-start fee | One completed run |
|---|---:|---:|---:|
| FREE | $0.57144 | $0.02 | $0.59144 |
| BRONZE | $0.14286 | $0.005 | $0.14786 |
| SILVER | $0.13429 | $0.005 | $0.13929 |
| GOLD | $0.12572 | $0.005 | $0.13072 |

Enterprise plans use the live price shown by Apify before the run. These are per-search prices, not per-event prices. The event count does not change the charge. FREE means the Apify account plan; it does not mean the actor's searches cost zero.

The recorded example completed in seconds, but completion time is not guaranteed. Check current [actor pricing](https://apify.com/sian.agency/google-events-search-scraper?fpr=sian) before starting a run.

### ❓ Frequently Asked Questions

**How many event rows will I receive?**

One search-level dataset row, containing the complete nested event list and its count. This version performs one query per run.

**Is an empty search charged?**

Yes. A valid empty observation has `empty=true` and `events=[]` and costs one completed-search event. Failed retrievals have no search-event charge. The separate run-start fee still applies.

**Is the date preference a strict filter?**

No. It guides the search. Check the returned dates and organizer information before treating an event as within a date period.

**Does it verify tickets or include every venue detail?**

No. It returns event search listings. Links and enriched details may be missing. It does not confirm ticket prices, inventory or availability.

**Can I use an empty API input?**

Supply your own query. The Console example is a prefill, not an API default.

**Can I automate repeated searches?**

Yes. Save an input and use Apify Schedules. Each run creates a new observation and has its own charges.

**Which export format should I choose?**

JSON preserves nested event records. CSV and Excel suit the search summary fields and may encode nested data as text.

### 🐛 Troubleshooting

**No events returned**

Try a broader phrase, another location or any date. An empty completed search is billable; check your query before starting another run.

**Unexpected event dates**

The date preference is a hint. Inspect actual dates and venues, then follow the organizer's information before using a listing.

**Links or detailed times are missing**

These fields are optional and may not appear in search results. The actor does not perform a separate event-detail lookup.

**The run stops before searching**

Read the processing report. Check the maximum charge and account allowance. No completed-search event is charged when retrieval does not begin.

**Temporarily unavailable**

Wait before retrying. The actor does not automatically retry a data search; failed retrievals do not incur a completed-search event.

### ⚖️ Legal Disclaimer

Results describe public event listings and may include names or contact information that identify people. Use them for a legitimate purpose and follow applicable privacy rules, including GDPR, and service terms.

For background, read [Apify's explanation of web scraping legality](https://blog.apify.com/is-web-scraping-legal/). Ask qualified counsel when you need advice for your use case.

Google and Google Events are trademarks of Google LLC. SIÁN Agency is independent and is not affiliated with or endorsed by Google.

### 🤝 Support

Use the actor's [Issues tab](https://apify.com/sian.agency/google-events-search-scraper/issues) for reproducible problems. Include the input and run URL, with sensitive information removed.

- 🛠️ [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian)
- 📧 <apify@sian-agency.online>

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Changelog

This Actor's version history is a separate document: https://apify.com/sian.agency/google-events-search-scraper/changelog.md

# Actor input Schema

## `operation` (type: `string`):

Run one event search. One completed-search record contains the entire returned event list; a valid empty search is a completed, billable observation. Failed retrievals have no search-event charge.

## `query` (type: `string`):

Search phrase describing the event and location, such as concerts in San Francisco. Required at runtime. The Console example is prefilled; API callers must supply their own query.

## `dateHint` (type: `string`):

Adds a date phrase to the search. This is a search hint, not a guaranteed date filter. Check each returned event date before using it in a calendar.

## Actor input object example

```json
{
  "operation": "search",
  "query": "concerts in San Francisco",
  "dateHint": "any"
}
```

# Actor output Schema

## `googleEventsEventSearches` (type: `string`):

Google Events search records with names, date labels, venues and full nested event data. JSON retains every returned event.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "search",
    "query": "concerts in San Francisco",
    "dateHint": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/google-events-search-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 = {
    "operation": "search",
    "query": "concerts in San Francisco",
    "dateHint": "any",
}

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

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

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

```

## CLI example

```bash
echo '{
  "operation": "search",
  "query": "concerts in San Francisco",
  "dateHint": "any"
}' |
apify call sian.agency/google-events-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/google-events-search-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/E598VeQyQNye8z8au/builds/oAF1Bspgjl8hMYjV0/openapi.json