# Brand Reviews Monitor (`luis.pinto/brand-reviews-monitor`) Actor

Monitor Google Maps reviews for any place and pipe new ones into Notion plus Slack notifications. AI agent dedupes by Review ID and posts per-review Slack messages. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/luis.pinto/brand-reviews-monitor.md
- **Developed by:** [Luis Pinto](https://apify.com/luis.pinto) (community)
- **Categories:** Lead generation, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.85 / 1,000 reviews

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

## Brand Reviews Monitor: Google Maps reviews to Notion and Slack

Track every new Google Maps review for any cafe, restaurant, hotel, or store, deduplicate against your Notion database, and ping Slack when feedback lands. For founders, hospitality operators, and brand managers who want reviews inside the tools the team already uses.

### What does Brand Reviews Monitor do?

Brand Reviews Monitor scrapes the latest Google Maps reviews for a place, deduplicates against your Notion database, inserts only new rows, and posts a Slack message for each. It uses Apify's Model Context Protocol (MCP) Connectors for Notion and Slack, so no API keys.

- Watches any public Google Maps place by URL
- Scrapes via Google Maps Reviews Scraper
- Maintains a 17-column Notion database
- Posts one Slack message per new review (cap 5 plus summary)
- Writes a run summary on the parent Notion page

Connect Notion first, verify the layout, then add Slack.

### What review data can you extract with Brand Reviews Monitor?

Brand Reviews Monitor captures the full review payload plus place and run metadata. Notion is the source of truth; the dataset stores a per-run snapshot.

| Reviewer | Review | Place and run |
|---|---|---|
| 👤 Name, photo, profile URL | ⭐ Stars (1-5), text, translation | 🏪 Place name, address, city |
| 🏅 Local Guide, review count | 🌐 Language, likes count | 🆔 Review ID (dedup key) |
| 📍 City (if public) | 🔗 Direct review URL | 🕒 Published / scraped at |
| | 💬 Owner response and date | 🛰️ Source (google, tripadvisor) |

Set `maxReviews` to 5 first, confirm columns, then scale up.

### Can I use Brand Reviews Monitor to track cafes, restaurants, hotels, and stores?

Yes. Brand Reviews Monitor works on any public Google Maps listing: cafes, restaurants, hotels, stores, salons, gyms, dealerships, dental clinics, museums, and gas stations. Pass a URL containing `/maps/place`, `/maps/search`, or `/maps/reviews`. Reviews return in the requested language with the original text next to the translation.

For chains, run one Apify schedule per location, each with its own Notion sub-page.

### How does Brand Reviews Monitor work?

A deterministic JavaScript pipeline runs dedup and inserts; a small LLM call writes the run summary. Reviews are never inserted twice because dedup runs in code against the Review ID column.

1. **Connect** the Notion MCP Connector, optionally Slack.
2. **Scrape** Google Maps reviews newest-first, capped by `maxReviews`.
3. **Deduplicate and insert** rows in Notion by Review ID.
4. **Notify** in Slack, one message per new review (cap 5 plus summary).
5. **Summarize** the run on the parent Notion page.

If a run looks off, check the run log first, then Notion, then Slack.

### Why use Brand Reviews Monitor?

Off-the-shelf review SaaS locks you into a proprietary dashboard and per-seat license. Brand Reviews Monitor keeps data in Notion, alerts in Slack, and schedules on the Apify platform.

| Feature | Review SaaS | Brand Reviews Monitor |
|---|---|---|
| Storage | Proprietary dashboard | Your Notion database, full export |
| Notifications | Email or app inbox | One Slack message per new review |
| Setup | Sign-up, billing, seats | One MCP Connector, one run |
| Dedup | Built-in but opaque | Review ID match in Notion |
| Schedule | Monthly or weekly | Apify Schedules, hourly to weekly |
| Pricing | USD 20 to 200 / month | Pay-per-event, cents per run |

Pick it when you already use Notion and Slack.

### What can you do with Google Maps review data?

- **Founder alerts**: hourly runs ping Slack the second a review lands.
- **Hospitality triage**: sub-3-star reviews hit Slack so a manager calls back same-day.
- **Marketing testimonials**: weekly Notion view of top-liked 5-star reviews feeds the next campaign.
- **Multi-location chains**: one schedule per franchise, one Notion sub-page per location.
- **Competitor benchmarking**: track five competitors, compare star trends month over month.

Run hourly for busy restaurants and hotels, daily for most cafes and stores.

### How to use Brand Reviews Monitor

1. **Create an Apify account** at [apify.com](https://apify.com).
2. **Authorize MCP Connectors** under **Settings > API & Integrations**: Notion (required), Slack (optional).
3. **Create a Notion parent page**, open **Connections**, add the Apify integration.
4. **Open Brand Reviews Monitor** in Apify Store, click **Try for free**.
5. **Paste the Google Maps URL**, pick the Notion Connector and parent page URL.
6. **(Optional)** pick the Slack Connector and channel.
7. **Click Start.** First run creates the database and inserts current reviews.
8. **Schedule** under **Schedules** in Apify Console for unattended monitoring.

Start with `maxReviews: 5`, then scale.

### How much will Brand Reviews Monitor cost?

Pay-per-event pricing. You pay for the Google Maps Reviews Scraper call, a small LLM cost for the run summary, and Apify compute. A daily run with `maxReviews: 50` costs USD 0.03 to USD 0.05, or USD 1 to USD 2 per month per place. See the Pricing tab.

Lower `maxReviews` after backfill, or set `reviewsStartDate` to `2 days` to cut cost.

### ⬇️ Input

| Field | Required | Notes |
|---|---|---|
| `placeUrl` | Yes | Google Maps URL (`/maps/place`, `/maps/search`, `/maps/reviews`). |
| `notionConnector` | Yes | Notion MCP Connector (else dry-run). |
| `notionParentPageUrl` | Recommended | Page where the database lives. |
| `slackConnector` | Optional | Enables Slack notifications. |
| `slackChannel` | Optional | With or without `#`. |
| `maxReviews` | No (50) | Per-run cap, newest-first. |
| `reviewsStartDate` | Optional | `2026-05-03` or `7 days`. |
| `language` | No (`en`) | Two-letter code. |
| `customInstructions` | Optional | 200 chars max. |

```json
{
  "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery",
  "notionConnector": "conn_YOUR_NOTION_ID",
  "notionParentPageUrl": "https://www.notion.so/Brand-reviews",
  "slackConnector": "conn_YOUR_SLACK_ID",
  "slackChannel": "#brand-reviews",
  "maxReviews": 50
}
````

Try the prefilled URL once, then swap in your own.

### ⬆️ Output

One dataset row per run with counts, insert summary, and Slack summary. The live artifact is the Notion database plus the Slack channel.

```json
{
  "runId": "abc123",
  "placeName": "SF Street Bakery",
  "scrapedCount": 12,
  "newCount": 3,
  "notionInserts": { "ok": 3, "failed": 0 },
  "slackNotifications": { "sent": 3, "failed": 0 },
  "notionDatabaseUrl": "https://www.notion.so/Brand-Reviews"
}
```

Export as JSON, CSV, or Excel, or pull via the API.

### How to run Brand Reviews Monitor via the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/luis.pinto~brand-reviews-monitor/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery",
    "notionConnector": "conn_YOUR_NOTION_ID",
    "notionParentPageUrl": "https://www.notion.so/Brand-reviews",
    "slackChannel": "#brand-reviews",
    "maxReviews": 50
  }'
```

Poll with `GET /v2/actor-runs/RUN_ID`, pull rows with `GET /v2/datasets/DATASET_ID/items`.

### Are there other review and brand-monitoring tools on Apify Store?

- [Google Maps Reviews Scraper](https://apify.com/compass/Google-Maps-Reviews-Scraper): underlying scraper for one-off pulls.
- [Competitor Price Tracker](https://apify.com/luis.pinto/competitor-price-tracker): same MCP pattern, for pricing.
- [Klaviyo Campaign Drafter](https://apify.com/luis.pinto/klaviyo-campaign-drafter): sister Actor for email campaigns.

### Limitations

- **Newest-first only.** Google Maps Reviews Scraper sorts by newest, so old reviews fall outside the per-run cap. Use `reviewsStartDate` or raise `maxReviews` for backfill.
- **Review ID is the dedup key.** Owner responses added later to a tracked review are not re-detected. Re-run on a fresh database to capture current owner responses.
- **One place per run.** Chains need one Apify schedule per location.

### FAQ

**Can I scrape reviews from Yelp, TripAdvisor, or Booking.com?**
Not in v1. Brand Reviews Monitor uses Google Maps Reviews Scraper. Yelp and Booking.com need separate Apify Actors.

**How many reviews can Brand Reviews Monitor scrape per run?**
Between 1 and 1,000 via `maxReviews`. Default 50 fits daily monitoring; 200+ for backfill.

**How often should I schedule Brand Reviews Monitor?**
Hourly for busy restaurants and hotels, daily for most cafes and stores, weekly for low-traffic specialty businesses.

**Can I use Brand Reviews Monitor with Zapier, Make, n8n, or Google Sheets?**
Yes. Wire the run-succeeded webhook into Zapier, Make, or n8n, or pull the dataset into Google Sheets via the Apify integration.

**Can I use Brand Reviews Monitor with the Apify API?**
Yes. See the curl example above. Authenticate with `Authorization: Bearer YOUR_APIFY_TOKEN` and poll the run and dataset endpoints.

**Can I use Brand Reviews Monitor through an MCP Server?**
Yes. Every public Apify Actor is callable from MCP-aware AI agents (Claude, Cursor, ChatGPT) via the Apify Actor MCP Server.

**Is scraping Google Maps reviews legal?**
Public review data is generally lawful in the US and EU (hiQ Labs v. LinkedIn, 2022). Respect Google's Terms of Service.

### Your feedback

Bug or feature request? File it on the [Issues tab](https://console.apify.com/actors/luis.pinto~brand-reviews-monitor/issues).

# Actor input Schema

## `placeUrl` (type: `string`):

URL of the Google Maps place to monitor. The Actor scrapes the latest reviews via Apify's Google Maps Reviews Scraper. Must contain /maps/place, /maps/search, or /maps/reviews in the path. Any cafe, restaurant, store, or hotel works. To get one: search the place on Google Maps, click it, copy the browser URL. Either this OR sourceDatasetId is required (sourceDatasetId wins if both are set).

## `sourceDatasetId` (type: `string`):

Apify dataset ID of an EXISTING reviews scrape (e.g. from a scheduled run of Google Maps Reviews Scraper). When provided, the Actor skips scraping and reads the reviews directly from this dataset. Use this for composability: scrape once, sync to multiple destinations, or chain Actors via webhooks. Either this OR placeUrl is required. Overrides placeUrl when both are set.

## `notionConnector` (type: `string`):

Notion MCP Connector used to maintain the review-tracking database. The Actor creates the 'Brand Reviews Tracker' database on the first run, dedups by Review ID, and inserts new reviews only. Authorize a Notion Connector under Apify Console > Settings > API & Integrations > MCP Connectors, then add it to the page where the database should live.

## `slackConnector` (type: `string`):

Slack MCP Connector for notifications. When provided, the Actor posts a Slack message for every new review found this run (up to 5 individual messages plus a summary line for any extras). Leave blank to skip Slack notifications and only update the Notion database.

## `notionParentPageUrl` (type: `string`):

URL of the Notion page where the review database should live. Strongly recommended. Without this, the search has to scan the workspace and may pick the wrong location. Create a Notion page (for example 'Brand Reviews'), add the Apify integration via the page menu > Connections, then paste the URL here.

## `slackChannel` (type: `string`):

Channel to post notifications to (for example '#brand-reviews', '#general'). Channel name with or without '#'.

## `maxReviews` (type: `integer`):

Maximum reviews to scrape this run, sorted newest first. Only applies when scraping via placeUrl. When reading from sourceDatasetId, all items in the dataset are processed (Notion dedup ensures only new ones are inserted). Recommended: 50 for daily monitoring of small businesses; 200+ for backfill on busy places.

## `reviewsStartDate` (type: `string`):

Absolute date ('2024-05-03') or relative ('7 days', '1 month'). Restricts the scraper to reviews newer than this point. Only applies when scraping via placeUrl (ignored when reading from sourceDatasetId).

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

Two-letter language code (for example 'en', 'pt', 'fr'). Affects review translation behavior. Only applies when scraping via placeUrl.

## Actor input object example

```json
{
  "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery/data=!4m2!3m1!1s0x5491750868ad72b3:0x1b6569df54b3fa8a",
  "slackChannel": "#brand-reviews",
  "maxReviews": 50,
  "language": "en"
}
```

# Actor output Schema

## `dataset` (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 = {
    "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery/data=!4m2!3m1!1s0x5491750868ad72b3:0x1b6569df54b3fa8a",
    "slackChannel": "#brand-reviews",
    "maxReviews": 50,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("luis.pinto/brand-reviews-monitor").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 = {
    "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery/data=!4m2!3m1!1s0x5491750868ad72b3:0x1b6569df54b3fa8a",
    "slackChannel": "#brand-reviews",
    "maxReviews": 50,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("luis.pinto/brand-reviews-monitor").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 '{
  "placeUrl": "https://www.google.com/maps/place/San+Francisco+Street+Bakery/data=!4m2!3m1!1s0x5491750868ad72b3:0x1b6569df54b3fa8a",
  "slackChannel": "#brand-reviews",
  "maxReviews": 50,
  "language": "en"
}' |
apify call luis.pinto/brand-reviews-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=luis.pinto/brand-reviews-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Brand Reviews Monitor",
        "description": "Monitor Google Maps reviews for any place and pipe new ones into Notion plus Slack notifications. AI agent dedupes by Review ID and posts per-review Slack messages. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "DDMpTuHRQdiBNUPc9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/luis.pinto~brand-reviews-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-luis.pinto-brand-reviews-monitor",
                "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/luis.pinto~brand-reviews-monitor/runs": {
            "post": {
                "operationId": "runs-sync-luis.pinto-brand-reviews-monitor",
                "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/luis.pinto~brand-reviews-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-luis.pinto-brand-reviews-monitor",
                "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",
                "properties": {
                    "placeUrl": {
                        "title": "Google Maps place URL (simple mode)",
                        "type": "string",
                        "description": "URL of the Google Maps place to monitor. The Actor scrapes the latest reviews via Apify's Google Maps Reviews Scraper. Must contain /maps/place, /maps/search, or /maps/reviews in the path. Any cafe, restaurant, store, or hotel works. To get one: search the place on Google Maps, click it, copy the browser URL. Either this OR sourceDatasetId is required (sourceDatasetId wins if both are set)."
                    },
                    "sourceDatasetId": {
                        "title": "Reviews dataset ID (advanced mode)",
                        "type": "string",
                        "description": "Apify dataset ID of an EXISTING reviews scrape (e.g. from a scheduled run of Google Maps Reviews Scraper). When provided, the Actor skips scraping and reads the reviews directly from this dataset. Use this for composability: scrape once, sync to multiple destinations, or chain Actors via webhooks. Either this OR placeUrl is required. Overrides placeUrl when both are set."
                    },
                    "notionConnector": {
                        "title": "Notion MCP Connector",
                        "type": "string",
                        "description": "Notion MCP Connector used to maintain the review-tracking database. The Actor creates the 'Brand Reviews Tracker' database on the first run, dedups by Review ID, and inserts new reviews only. Authorize a Notion Connector under Apify Console > Settings > API & Integrations > MCP Connectors, then add it to the page where the database should live."
                    },
                    "slackConnector": {
                        "title": "Slack MCP Connector",
                        "type": "string",
                        "description": "Slack MCP Connector for notifications. When provided, the Actor posts a Slack message for every new review found this run (up to 5 individual messages plus a summary line for any extras). Leave blank to skip Slack notifications and only update the Notion database."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page URL (recommended)",
                        "type": "string",
                        "description": "URL of the Notion page where the review database should live. Strongly recommended. Without this, the search has to scan the workspace and may pick the wrong location. Create a Notion page (for example 'Brand Reviews'), add the Apify integration via the page menu > Connections, then paste the URL here."
                    },
                    "slackChannel": {
                        "title": "Slack channel (optional)",
                        "type": "string",
                        "description": "Channel to post notifications to (for example '#brand-reviews', '#general'). Channel name with or without '#'."
                    },
                    "maxReviews": {
                        "title": "Max reviews per run",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum reviews to scrape this run, sorted newest first. Only applies when scraping via placeUrl. When reading from sourceDatasetId, all items in the dataset are processed (Notion dedup ensures only new ones are inserted). Recommended: 50 for daily monitoring of small businesses; 200+ for backfill on busy places.",
                        "default": 50
                    },
                    "reviewsStartDate": {
                        "title": "Only scrape reviews newer than (optional)",
                        "type": "string",
                        "description": "Absolute date ('2024-05-03') or relative ('7 days', '1 month'). Restricts the scraper to reviews newer than this point. Only applies when scraping via placeUrl (ignored when reading from sourceDatasetId)."
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Two-letter language code (for example 'en', 'pt', 'fr'). Affects review translation behavior. Only applies when scraping via placeUrl.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
