# Google Maps Owner Updates, Offers & Events Monitor (`xyrelith-data/google-maps-business-posts`) Actor

Collect the updates, offers and events a business publishes on Google Maps. Search a market or paste place links, read post text, dates, photos, videos and call-to-action buttons, audit posting activity, and emit only new posts on scheduled runs.

- **URL**: https://apify.com/xyrelith-data/google-maps-business-posts.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Automation, Lead generation, Social media
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Maps Owner Updates, Offers & Events Monitor

Businesses publish short posts on their Google Maps listing: a new menu item, a seasonal discount, a
weekend event, a service notice. Those posts are public, but Google Maps shows only one or two of
them at a glance and keeps the rest behind a "Latest Posts" view. This Actor collects them as clean
rows — the text, publish date, photos, videos, offer or event dates, and the call-to-action button —
for one business, a list of businesses, or a whole local market found by search.

Run it once for an export. Run it on a schedule with **Only new posts** turned on to watch a set of
competitors and receive only what changed since the previous run.

No Google account, API key, cookie or proxy setup is needed.

### What you can do with it

- **Competitor monitoring.** Follow the offers, events and announcements a local market publishes,
  and see who is active and who has gone quiet.
- **Local SEO audits.** Compare posting frequency across dentists, gyms, restaurants or car dealers
  in a city, with days since the last post and 30/90-day posting counts.
- **Offer and event research.** Collect current promotions with their validity dates, images and
  destination links.
- **Lead generation.** Find businesses that never post, or that post often, as a starting point for
  marketing outreach.
- **Brand archiving.** Keep a dated record of every post a multi-location brand publishes, with its
  media and button link.
- **Content research.** See the wording, hashtags, links and calls to action that businesses in a
  niche actually use.

### Input

| Field | Default | What it does |
|---|---|---|
| `placeInputs` | – | One business per line. Accepts a Google Maps place link (full link or `maps.app.goo.gl` share link), a Place ID (`ChIJ…`), a CID, a `0x…:0x…` feature ID, a `"business name, city"` phrase, or a Google Maps search link. |
| `searchTerms` | – | Business types or keywords to search on Google Maps, such as `dentist` or `car dealership`. Each term is combined with the location. |
| `location` | – | A city, region or address added to every search term, for example `Austin, TX`. Coordinates such as `34.05,-118.24` anchor the map instead. |
| `maxPlacesPerSearch` | `10` | How many of the first businesses Google Maps lists for each search term are read. |
| `maxPostsPerPlace` | `10` | How many of the newest posts are read per business. The type and date filters are applied inside that reading window. |
| `postTypes` | – | Deliver only updates, offers, events or alerts. Leave empty for every kind. |
| `postedWithinDays` | `0` | Deliver only posts published in the last N days. `0` means any age. |
| `maxItems` | `500` | Stop after this many rows. Summary rows count toward the limit, and a business's summary is written before its posts. |
| `includePosts` | `true` | Write one row per post. Turn this off for an activity-only report. |
| `includePlaceSummaries` | `true` | Write one activity row per business, including businesses with no posts. |
| `onlyNewPosts` | `false` | Monitor mode. Skips posts already delivered under the same monitor name. |
| `monitorName` | `default` | Keeps separate seen-post histories for different schedules or markets. |
| `language` | `en` | Language code for Google Maps labels and relative dates (`en`, `es`, `de`, `pt-BR`, …). Business-written post text is never translated. |
| `country` | `us` | Two-letter country code for the local view (`us`, `gb`, `au`, …). |

You can combine **Places** and **Search terms** in one run. A business found by more than one path is
read once.

#### Example input

```json
{
  "placeInputs": [
    "https://maps.app.goo.gl/example",
    "ChIJG8JxzsbHwoARAywbA13iB5E",
    "10450570349448473603"
  ],
  "searchTerms": ["dentist"],
  "location": "Austin, TX",
  "maxPlacesPerSearch": 10,
  "maxPostsPerPlace": 20,
  "postTypes": ["offer", "event"],
  "postedWithinDays": 90,
  "includePosts": true,
  "includePlaceSummaries": true,
  "language": "en",
  "country": "us"
}
```

### Output

Each run writes post rows and one activity summary row per business. Places with no owner posts get
a summary row with zero posts — never an error.

#### Post row

| Field | Meaning |
|---|---|
| `recordType` | `post`. |
| `postId` | Google's ID for the post. Stable across runs. |
| `postType` | `update`, `offer`, `event`, `alert` or `post`. |
| `title` | The title of an offer or event. Updates usually have none. |
| `text` | The post's text, with its paragraphs, line breaks, emoji, links and hashtags kept readable. |
| `links` | Links written in the post text. |
| `hashtags` | Hashtags used in the post text, without the `#`. |
| `publishedAt` | ISO 8601 UTC publish time resolved from Google's timestamp. |
| `postedLabel` | The date as Google prints it, for example `3 days ago` or `Nov 7, 2026`. |
| `expiresAt` | ISO date until which Google shows the post. |
| `startDate`, `endDate` | The offer or event validity dates, in the business's time zone. |
| `dateRangeLabel` | The dates as Google writes them, for example `Nov 11 - Nov 18`. |
| `offerBadge` | The short discount badge Google shows on some offers. |
| `offerCouponCode` | A coupon or promo code written in the offer text, when the business included one. |
| `offerRedeemUrl` | The offer's redeem link, when it has a call-to-action URL. |
| `ctaType` | Normalised button type: `book`, `order_online`, `buy`, `learn_more`, `call`, `sign_up` or `view_offer`. |
| `ctaLabel` | The button label in the chosen language. |
| `ctaUrl` | The button's destination link. |
| `ctaPhone` | The phone number behind a **Call now** button. |
| `imageUrls` | Full-resolution post images. |
| `videoUrls` | Post videos (MP4). |
| `videoThumbnailUrls` | Thumbnails for the post videos. |
| `imageCount`, `videoCount` | How many images and videos the post has. |
| `postUrl` | The post's public Google page. |
| `positionInPlace` | The post's 1-based position among the delivered posts for this business. |
| `businessName`, `placeId`, `cid`, `featureId`, `kgmid` | Business identifiers. |
| `address`, `category`, `categories` | Business location and categories. |
| `rating`, `reviewCount`, `phone`, `website` | Business profile details. |
| `latitude`, `longitude`, `timezone`, `mapsUrl` | Business coordinates, time zone and Maps link. |
| `sourceInput`, `searchTerm`, `searchRank` | The place input or search that produced the record. |
| `scrapedAt` | When the record was collected. |

#### Place summary row

| Field | Meaning |
|---|---|
| `recordType` | `place`. |
| `status` | `ok`, `noPosts`, `noNewPosts`, `noMatchingPosts`, `partial`, `notFound`, `invalid` or `unreachable`. |
| `statusReason` | Plain-language explanation of the status. |
| `postsFound` | How many post rows this run delivered for the business. |
| `postsScanned` | How many unique posts were read. |
| `newPosts` | How many delivered posts were not seen in the previous monitor run. |
| `postTypeCounts` | How many updates, offers, events and alerts were read. |
| `newestPostAt`, `newestPostLabel` | The newest post's publish time and Google's label. |
| `oldestPostAt` | The oldest post read. |
| `daysSinceLastPost` | Whole days since the newest post. |
| `postsLast30Days`, `postsLast90Days` | Posting frequency in the two windows. |
| `offerPostShare`, `eventPostShare` | Share of the read posts that are offers or events, as a percentage. |
| `stopReason` | `maxPostsReached`, `sourceExhausted` or `paginationError`. |
| `businessName`, `placeId`, `cid`, `featureId`, `kgmid`, `address`, `category`, `rating`, `reviewCount`, `phone`, `website`, `latitude`, `longitude`, `timezone`, `mapsUrl` | Business profile details. |
| `sourceInput`, `searchTerm`, `searchRank`, `scrapedAt` | Provenance of the row. |

A search that returns no businesses writes a `search` row with `status: "noResults"` so the run
explains itself.

#### Example post row

```json
{
  "recordType": "post",
  "postId": "1722777834167716913",
  "postType": "offer",
  "title": "5% OFF - Military Discount",
  "text": "5% OFF",
  "publishedAt": "2026-11-12T05:05:45+00:00",
  "postedLabel": "3 days ago",
  "expiresAt": "2026-11-18",
  "startDate": "2026-11-11",
  "endDate": "2026-11-18",
  "dateRangeLabel": "Nov 11 - Nov 18",
  "offerBadge": "5% OFF",
  "ctaType": "learn_more",
  "ctaLabel": "Learn more",
  "ctaUrl": "https://www.example.com/service-coupons",
  "imageUrls": ["https://lh3.googleusercontent.com/geougc/…=s0"],
  "imageCount": 1,
  "postUrl": "https://search.google.com/local/posts?q=…",
  "positionInPlace": 2,
  "businessName": "Honda of Downtown Los Angeles",
  "placeId": "ChIJG8JxzsbHwoARAywbA13iB5E",
  "address": "780 W Martin Luther King Jr Blvd, Los Angeles, CA 90037",
  "category": "Honda dealer",
  "mapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJG8JxzsbHwoARAywbA13iB5E",
  "scrapedAt": "2026-11-15T08:46:27+00:00"
}
```

### Monitor mode

Turn on **Only new posts since the previous run** and give the monitor a name. The Actor stores the
IDs of posts it delivered in its key-value store. On the next run with the same name, already
delivered posts are skipped, so a daily or weekly schedule reports only what is new. A business with
posts but no new ones still gets a summary row with `status: "noNewPosts"` and `newPosts: 0`.

Use a different monitor name for each independent schedule. If you turn monitor mode off, runs still
record what they deliver, so the next monitor run starts from that baseline.

### How many posts can I get?

Google Maps keeps older posts reachable. The Actor reads the first page of posts with the place
profile and then follows Google's older-post pages, so a business that has posted for years can
return hundreds of posts. **Maximum posts per business** is the upper bound; the hard safety cap is
1,000 posts per business. Businesses that never posted return a zero-post summary row.

### What counts as an offer or an event?

Google stores date-bounded posts as events on the public profile. This Actor labels a date-bounded
post as an **offer** when its title or text contains a price or discount signal (`5% OFF`,
`$27,872`, `0% APR`, `save`, `coupon`, `sale`, `deal`), and as an **event** otherwise. Updates are
Google's "What's new" posts. Alerts are the older notice-style posts. The original Google post is
always available in `text` and `dateRangeLabel`, and `postType` is a convenience filter, not a
rewritten fact.

### Limitations

- Only public owner posts are collected. Customer reviews, customer photos and reviewer profiles
  are different surfaces and are not included.
- Posts a business deleted or that Google stopped showing cannot be read.
- Many businesses simply have no posts. In a Los Angeles sample, roughly one in three businesses
  had at least one post; the rest correctly return a zero-post summary.
- Offer coupon codes and full terms are not published as a separate structured block. A code
  written in the post is extracted into `offerCouponCode`; the full terms remain in `text`, and the
  button link is in `ctaUrl` (also `offerRedeemUrl` for offers).
- The public post link (`postUrl`) is the same link Google Maps' share menu produces. On some
  networks Google may show a bot-check page before the post; the link itself is valid.
- Language changes Google's labels, categories and relative dates. It does not translate the
  business's own text.
- The reading window is applied before the type/date filters. If you ask for 10 posts and also
  filter to offers, only offers among those 10 are delivered; raise **Maximum posts per business**
  to search further back.

### FAQ

**Do I need a Google API key or a Google account?**
No. The Actor reads the same public Maps pages a signed-out visitor sees.

**Why does a business have no post rows?**
Either it has never published a post, or its posts are older than the reading window you set, or none match the selected type/date filters. Its summary row says `noPosts`, `noNewPosts` or `noMatchingPosts` and still gives the posting activity it could see.

**Can I use place names instead of links?**
Yes, when Google Maps returns one clear match for the name. For an ambiguous name, paste the place
link or use search mode.

**Can I monitor several markets separately?**
Yes. Use one monitor name per market or schedule. The histories do not mix.

**Does it work outside the United States?**
Yes. Set the language and country to the market you want, and use the local business links or a
search term with a local area.

**Are the images and videos downloadable?**
Yes. `imageUrls` point to full-resolution images and `videoUrls` to MP4 files on Google's public
media host.

**What does `maxItems` count?**
Every dataset row, including summary rows. A business's summary is written before its posts.

**Can I get only the activity report without post rows?**
Yes. Turn off **Include post rows** and keep **Include place summary rows** on. You get one row per
business with posting frequency and recency.

**What happens if a place link is broken or a search finds nothing?**
The run does not crash. You get a summary row with `notFound`, `invalid` or `unreachable`, or a
search row with `noResults`, and the rest of the input continues.

### Data source

Public Google Maps business profiles and their public post pages. No login, cookie, API key or
third-party service is used. The Actor reads the signed-out view that any visitor can open.

# Actor input Schema

## `placeInputs` (type: `array`):

One business per line. A Google Maps place link (full or maps.app.goo.gl short link), a Place ID (ChIJ...), a CID, a 0x...:0x... feature ID, a "business name, city" phrase, or a Google Maps search link.

## `searchTerms` (type: `array`):

Business types or keywords to search on Google Maps, for example "dentist" or "car dealership". Each term is combined with the location below.

## `location` (type: `string`):

A city, region or address added to every search term (for example "Austin, TX"). You can also enter coordinates as "lat,lng" to anchor the map.

## `maxPlacesPerSearch` (type: `integer`):

How many businesses Google Maps lists first for each search term are read.

## `maxPostsPerPlace` (type: `integer`):

How many of the newest posts are read for each business. This is the reading window; the post type and date filters are applied inside it. Google Maps keeps older posts reachable, up to 1,000 per business.

## `postTypes` (type: `array`):

Only deliver these kinds of post. Leave empty for every kind.

## `postedWithinDays` (type: `integer`):

Deliver only posts published in the last N days. Use 0 for posts of any age.

## `maxItems` (type: `integer`):

Stop after this many rows. Summary rows count toward the limit, and a summary row is written before that business's posts.

## `includePosts` (type: `boolean`):

Write one row per post. Turn this off for an activity-only audit.

## `includePlaceSummaries` (type: `boolean`):

Write one activity row per business, including businesses with no posts. A business with no posts gets a zero-post row, never an error.

## `onlyNewPosts` (type: `boolean`):

Monitor mode. Posts already delivered under the same monitor name are skipped, so a scheduled run reports only what is new.

## `monitorName` (type: `string`):

Use a different name for each independent schedule or market you monitor. The name keeps their seen-post histories separate.

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

Language code for Google Maps labels, categories and relative dates (for example en, es, de, pt-BR). The businesses' own post text is never translated.

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

Two-letter country code Google answers for (for example us, gb, au). Use the businesses' country for the local view.

## Actor input object example

```json
{
  "placeInputs": [
    "ChIJG8JxzsbHwoARAywbA13iB5E"
  ],
  "searchTerms": [],
  "location": "",
  "maxPlacesPerSearch": 3,
  "maxPostsPerPlace": 2,
  "postTypes": [],
  "postedWithinDays": 0,
  "maxItems": 3,
  "includePosts": true,
  "includePlaceSummaries": true,
  "onlyNewPosts": false,
  "monitorName": "default",
  "language": "en",
  "country": "us"
}
```

# Actor output Schema

## `posts` (type: `string`):

Dataset containing post rows and one posting-activity summary row per business.

# 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 = {
    "placeInputs": [
        "ChIJG8JxzsbHwoARAywbA13iB5E"
    ],
    "searchTerms": [],
    "location": "",
    "maxPlacesPerSearch": 3,
    "maxPostsPerPlace": 2,
    "postTypes": [],
    "postedWithinDays": 0,
    "maxItems": 3,
    "includePosts": true,
    "includePlaceSummaries": true,
    "onlyNewPosts": false,
    "monitorName": "default",
    "language": "en",
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/google-maps-business-posts").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 = {
    "placeInputs": ["ChIJG8JxzsbHwoARAywbA13iB5E"],
    "searchTerms": [],
    "location": "",
    "maxPlacesPerSearch": 3,
    "maxPostsPerPlace": 2,
    "postTypes": [],
    "postedWithinDays": 0,
    "maxItems": 3,
    "includePosts": True,
    "includePlaceSummaries": True,
    "onlyNewPosts": False,
    "monitorName": "default",
    "language": "en",
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/google-maps-business-posts").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 '{
  "placeInputs": [
    "ChIJG8JxzsbHwoARAywbA13iB5E"
  ],
  "searchTerms": [],
  "location": "",
  "maxPlacesPerSearch": 3,
  "maxPostsPerPlace": 2,
  "postTypes": [],
  "postedWithinDays": 0,
  "maxItems": 3,
  "includePosts": true,
  "includePlaceSummaries": true,
  "onlyNewPosts": false,
  "monitorName": "default",
  "language": "en",
  "country": "us"
}' |
apify call xyrelith-data/google-maps-business-posts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/google-maps-business-posts"
        }
    }
}
```

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/GXV4Bt89F1BTFadbr/builds/HQSxmEGUHbFb9zf59/openapi.json
